[[Vorlage(getestet, focal, bionic)]]

[[Vorlage(Ausbaufähig, "Die Analyse bei der Nutzung einer [wikipedia:GUID_Partition_Table:GUID Partition-Table] (kurz GPT) kann noch weiter erklärt werden. Die Angaben im Abschnitt [#GRUB-Version-in-MBR-oder-Partitions-Bootsektor-ermitteln GRUB-Version in MBR oder Partitions-Bootsektor ermitteln] müssen evtl. angepasst werden.")]].

{{{#!vorlage Wissen
[:chroot/Live-CD: Mittels Live-CD und chroot in das installierte System wechseln]
[:Terminal: Ein Terminal öffnen]
[:Pakete installieren: Installation von Programmen]
[:Datenträger#Wie-heissen-die-Datentraeger:Wie heißen die Datenträger]
}}}
[[Inhaltsverzeichnis(1)]]

[[Bild(Wiki/Icons/Oxygen/system-search.png, 48, align=left)]]
Dieser Artikel beschreibt, wie man aus einem laufenden Ubuntu, einem [:Desktop-Live-Medium:] oder aber der [:GRUB_2/Shell#Kommandozeile: GRUB 2 Kommandozeile] heraus Informationen ermittelt, die für die Behebung oder Beschreibung von Problemen rund um GRUB 2 wichtig sind. Außerdem sind einige der Ausgaben hilfreich, sofern man GRUB 2 richtig [:GRUB_2/Skripte: manuell konfigurieren] will.

Wem das manuelle Zusammentragen der Informationen zu mühselig erscheint, kann dies auch bequem und umfassend von einem [#Umfassende-Analyse-mittels-Boot-Info-Script Script] erledigen lassen.

{{{#!vorlage hinweis
Die Vorgaben '''/dev/sdX''' bzw. '''/dev/sdXY'''[4] müssen im Folgenden immer durch die tatsächlichen Bezeichnung der Partitionen ersetzt werden!
}}}

=GRUB-Version=
{{{#!vorlage Hinweis
Die Befehle zur Versions-Ermittlung müssen im laufenden System ausgeführt werden, um die richtigen Ergebnisse zu liefern. Kann das System nicht mehr gestartet werden, so muss man von einem [:Desktop-Live-Medium:] aus mittels [:chroot:] in das laufende System wechseln [1] und dort den betreffenden Befehl ausführen. Alternativ kann man auch versuchen, das System mit der [:GRUB_2/Shell#Alternativer-Systemstart-mit-Hilfe-der-Super-GRUB2-Disk: Super-GRUB2-Disk] zu starten.
}}}

== GRUB UEFI- oder BIOS-Modus ==
Mit dem folgenden Befehl im Terminal [2] lässt sich feststellen, ob der UEFI- oder BIOS-Modus  im laufenden System installiert ist:

{{{#!vorlage Befehl
dpkg --list | grep grub
}}}
UEFI-Modus
{{{#!code bash
ii  grub-common           2.04-1ubuntu26.7         amd64   GRand Unified Bootloader (common files)
ii  grub-efi-amd64        2.04-1ubuntu26.7         amd64   GRand Unified Bootloader, version 2 (EFI-AMD64 version)
ii  grub-efi-amd64-bin    2.04-1ubuntu26.7         amd64   GRand Unified Bootloader, version 2 (EFI-AMD64 modules)
ii  grub-efi-amd64-signed 1.142.9+2.04-1ubuntu26.7 amd64   GRand Unified Bootloader, version 2 (EFI-AMD64 version, signed)
ii  grub2-common          2.04-1ubuntu26.7         amd64   GRand Unified Bootloader (common files for version 2)
}}} 
BIOS-Modus
{{{#!code bash
ii  grub-common           2.02-2ubuntu8.19         amd64   GRand Unified Bootloader (common files)
ii  grub-gfxpayload-lists 0.7                      amd64   GRUB gfxpayload blacklist
ii  grub-pc               2.02-2ubuntu8.19         amd64   GRand Unified Bootloader, version 2 (PC/BIOS version)
ii  grub-pc-bin           2.02-2ubuntu8.19         amd64   GRand Unified Bootloader, version 2 (PC/BIOS binaries)
ii  grub2-common          2.02-2ubuntu8.19         amd64   GRand Unified Bootloader (common files for version 2)
}}}
Neben dieser groben Unterscheidung zwischen GRUB UEFI- oder BIOS-Modus wird außerdem auch noch die genaue Paketversion aufgelistet.


Bevor man sich an die Problemlösung rund um GRUB 2 macht, sollte man sich daher vergewissern, dass man die für das Ubuntu Release neueste Paket-Version von GRUB 2 verwendet. Auch ein Update auf eine Paket-Version eines neueren Ubuntu-Releases [:GRUB_2/Installation#GRUB-2-mittels-Live-CD-auf-eine-Version-einer-neueren-Distribution-aktfind /boot/efi -iname "*efi" ualisieren: ist grundsätzlich möglich].

== os-prober-Version ==
Andere auf dem System installierte Betriebssysteme werden von GRUB 2 mittels des Paketes '''os-prober''' ermittelt. Die aktuell installierte Version erhält man mittels:

{{{#!vorlage Befehl
dpkg --list | grep os-prober
}}}

= Aktuelle GRUB-Konfiguration ausgeben =
Die aktuelle GRUB-Konfiguration ist in der Datei [:GRUB_2/Konfiguration#Standard-Eintraege-in-die-grub-cfg:/boot/grub/grub.cfg] gespeichert und kann mit folgendem Befehl angezeigt werden:

{{{#!vorlage Befehl
cat /boot/grub/grub.cfg
}}}

= Festplatten-Aufteilung und UUID =
Um die Konfiguration der GRUB-Menü-Einträge überprüfen zu können, muss man die Bezeichnung und Aufteilung der Festplatten im System kennen. Diese Informationen sind darüber hinaus wichtig, um bei der Installation entscheiden zu können, wohin GRUB 2 installiert werden soll. Damit man die Ausgaben der folgende Befehle richtig interpretieren kann, muss man außerdem verstanden haben, wie Datenträger und Partitionen unter Linux bezeichnet werden[4].

== Festplatten und Partitionen auflisten ==
{{{#!vorlage Befehl
sudo fdisk -lu
}}}
Der Befehl zeigt neben der Liste der Partitionen die Start- und Endsektoren der Partitionen an. Das ist hilfreich, wenn man wissen will, wie groß der sog. verborgene Bereich hinter dem MBR und vor der ersten Partition ist. Sehr häufig beginnt die erste Partition bei Sektor Nummer 63, seit Windows-Vista aber auch häufig erst bei Sektor Nummer 2048 (von der Sektorgröße der Festplatte abhängig).

Alternative:

Anstatt mit [:fdisk:] kann man sich die Partitionierung der Festplatten im System auch mit [:GNU_Parted:] ausgeben lassen. Das ist insbesondere dann vorzuziehen, wenn eine der Platten im System eine [wikipedia:GUID_Partition_Table: GPT] enthält, funktioniert aber natürlich auch bei Platten mit [wikipedia:Partitionstabelle:MBR-Partitionstabelle]:

{{{#!vorlage Befehl
sudo parted -l
}}}

{{{#!vorlage Warnung
Die Ausgabe von `fdisk -l` bzw. `parted -l` gibt keine verlässliche Auskunft über die Reihenfolge der Datenträger im System! Die Position der Datenträger ist bei heutiger Verwendung von externen Speichermedien – wie USB-Sticks und -Festplatten usw. – keinesfalls stets gleichbleibend.

Insbesondere vor der Verwendung der Befehle `grub-install` und `grub-setup` sollte man anhand der Auflistung der [#UUID-der-Dateisysteme-anzeigen UUIDs] vergleichen, dass der gewählte Datenträger auch tatsächlich die angenommenen Partitionen enthält.

Außerdem ist es zweckmäßig, bei Verwendung mehrerer Datenträger beim Anlegen der Partitionen (genauer: __beim Anlegen der Dateisysteme__), unterschiedliche Bezeichnungen zu vergeben, die dann das spätere Identifizieren der Datenträger und Partitionen erleichtern.
}}}

== UUID der Dateisysteme anzeigen ==
Der folgende Befehl listet die vorhandenen Partitionen, deren [:Dateisystem:], die Bezeichnung (engl. "label"), den Einhängepunkt (engl. "mount point") sowie die [:UUID:] auf:
{{{#!vorlage Befehl
sudo blkid -o list -w /dev/null
}}}
Mehr Informationen finden sich in den Artikeln [:UUID:] und [:blkid:].

Alternativ kann man auch den Befehl [:lsblk:] nutzen, dessen Ausgabe u.U. übersichtlicher wirkt:
{{{#!vorlage Befehl
lsblk -o name,uuid,fstype,mountpoint,label,size
}}}

= Bootsektor analysieren =
GRUB 2 installiert, je nach Partitions-Tabellentyp, wesentliche Teile in verschiedene Bereiche. Bei Problemen kann es notwendig sein, diese Bereiche näher zu untersuchen. 

Generelle Informationen zum Datenträger und GRUB:
{{{#!vorlage Befehl
sudo file -s -N -F';' /dev/sd*|egrep 'GR|ID=0xee|data$'| tr -s ';' '\n'}}}

== Partitionstabellen ==
Da weder beim MBR (bzw. der Bereich dahinter) noch bei einer GPT ohne (U)EFI ein [:Dateisysteme: Dateisystem] vorhanden ist, können die dortigen Informationen nur mittels `hexdump` ausgelesen werden.

{{{#!vorlage Hinweis
Man sollte sich von der Verwendung des `hexdump`-Befehls und den damit teilweise einhergehenden Ausgaben von Byte-Werten nicht abschrecken lassen. Im wesentlichen geht es nur darum, den Wert eines bestimmten Byte oder einer Folge von Bytes anzeigen zu lassen und diese dann anhand von Tabellen auszuwerten.
}}}

=== MBR-Partitionstabelle ===
 * Der Wert `512` muss bei allen 3 Befehlen gegebenenfalls dem eigenen System entsprechend angepasst werden (siehe [#Festplatten-und-Partitionen-auflisten Festplatten-Analyse/Sektoren]).

==== MBR anzeigen ====
{{{#!vorlage Befehl
sudo hexdump -s0 -n512 -C /dev/sdX 
}}}

==== Verborgenen Bereich anzeigen ====
{{{#!vorlage Befehl
sudo hexdump -s512 -n$((512*62)) -C /dev/sdX 
}}}


==== Partitions-Bootsektor anzeigen ====
{{{#!vorlage Befehl
sudo hexdump -s0 -n512 -C /dev/sdXY 
}}}

=== GPT ohne (U)EFI ===
Bei der Nutzung einer GPT __ohne__ (U)EFI wird eine eigene [:GRUB_2/Grundlagen#MBR-mit-GUID-Partitionstabelle-GPT:Boot-Partition] genutzt. Diese Partition muss die 1. Partition auf dem Datenträger sein, ihre Kennung ist ''ef02''.  
 * Der Wert `512` muss gegebenenfalls dem eigenen System entsprechend angepasst werden (siehe [#Festplatten-und-Partitionen-auflisten Festplatten-Analyse/Sektoren]).

==== GPT-Header anzeigen ====
{{{#!vorlage Befehl
sudo hexdump -s512 -n512 -C /dev/sdX 
}}}

==== BIOS Boot-Partition anzeigen ====

{{{#!vorlage Befehl
sudo hexdump -C /dev/sdXY 
}}}

=== GPT mit (U)EFI ===
Bei der Nutzung einer GPT mit (U)EFI wird eine eigene [:GRUB_2/Grundlagen/#Mit-EFI:Boot-Partition] genutzt. Diese Partition kann die 1. Partition auf dem Datenträger sein, ihre Kennung ist `ef00`.  

==== GPT-Header anzeigen ====
{{{#!vorlage Befehl
sudo hexdump -s1 -n512 -C /dev/sdX 
}}}

==== Boot-Loader listen ====
{{{#!vorlage Befehl
find /boot/efi -iname "*efi"
}}}

=== GRUB-Version in MBR oder Partitions-Bootsektor ermitteln ===
Die Informationen über die installierte GRUB-Version sind im MBR bzw. Partitions-Bootsektor in den zwei Byte ab Adresse `0x80` abgelegt.

==== Manuelles Ermitteln der GRUB-Version ====
Der folgende Befehl gibt den Wert der beiden Bytes ab Adresse 0x80 aus:

{{{#!vorlage Befehl
sudo hexdump -v -s 0x80 -n  2 -e '2/1 "%x" "\n"'  /dev/sdXY
}}}
Dem ausgegeben Wert kann über die folgende Tabelle die entsprechende Boote-Code-Version zugeordnet werden. Die Tabelle stammt aus dem [#Umfassende-Analyse-mittels-Boot-Info-Script Boot Info Script]:

|| <rowclass="titel" :>'''Byte-Wert''' || '''MBR bzw. Partitions-Bootsektor deutet auf folgenden Bootcode hin''' ||
|| <(-2, rowclass="kopf") :> '''GRUB-Byte-Kennungen''' ||
|| `5272` || GRUB (Legacy) ||
|| `aa75` || GRUB (Legacy) ||
|| `48b4` || GRUB 2 (Version 1.96) ||    
|| `7c3c` || GRUB 2 (Version 1.97 oder 1.98) ||
||  `020` || GRUB 2 (Version 1.99) ||
||  `488` || Grub 2 core.img ||
|| `31d2` || Grub 2 core.img ||
|| <(-2, rowclass="kopf") :> '''Byte-Kennungen anderer Systeme'''||
||  `069` || ISOhybrid (Syslinux 3.72-3.73) ||
||  `10f` || HP Recovery ||
||  `19d` || BSD4.4: Fat32 ||
||  `211` || Dell Utility: Fat16 ||
||  `689` || Syslinux 3.00-3.52 ||
||  `734` || Dos_1.0 ||
||  `745` || Vista: Fat 32 ||
||  `89e` || MSDOS5.0: Fat 16 ||
||  `8cd` || Windows XP ||
||  `b60` || Dell Utility: Fat16 ||
||  `bd0` || MSWIN4.1: Fat 32 ||
||  `e00` || Dell Utility: Fat16 ||
||  `fb6` || ISOhybrid mit unterstützter Partitionierung (Syslinux 3.82-3.86) ||
|| `2a00` || ReactOS ||
|| `2d5e` || Dos_1.1 ||
|| `31c0` || Syslinux 4.03 oder höher ||
|| `3a5e` || Recovery:Fat 32 ||
|| `407c` || ISOhybrid (Syslinux 3.82-4.04) ||
|| `4216` || Grub4Dos: NTFS ||
|| `4445` || DEll Restore: Fat32 || 
|| `55aa` || Windows Vista/7 ||
|| `55cd` || Fat32 ||
|| `5626` || Grub4Dos: EXT2/3/4 ||
|| `638b` || Freedos: FAT32 ||
|| `6616` || Fat16 ||
|| `696e` || Fat16 ||
|| `6974` || BootIt: Fat16 ||
|| `6f65` || BootIt: Fat16 ||
|| `6f6e` || MSWIN4.1: Fat 32 ||
|| `6f74` || Fat32 || 
|| `6f6e` || MSWIN4.1: Fat 32 ||
|| `74ef` || IBM ThinkPad von ca. 2006: bootet versteckte (Typ 0x12) FAT32-Recovery ||
|| `7815` || Syslinux 3.53-3.86 oder Fat32 ||
|| `7cc6` || MSWIN4.1: Fat 32, Win_98 ||
|| `7e1e` || Grub4Dos: FAT12/16 ||
|| `8a56` || Acronis SZ: Fat32 ||
|| `83e1` || ISOhybrid mit unterstützter Partitionierung (Syslinux 4.00-4.04) ||
|| `8ec0` || Windows XP ||
|| `8ed0` || DEll Recovery: Fat32 ||
|| `b106` || Syslinux 4.00-4.02 ||
|| `b600` || Dell Utility: FAT16 ||
|| `b6c6` || ISOhybrid mit unterstützter Partitionierung (Syslinux 3.81) ||
|| `b6d1` || Windows XP: FAT32 ||
|| `e2f7` || FAT32, nicht bootbar ||
|| `e879` || ISOhybrid (Syslinux 3.74-3.80) ||
|| `e9d8` || Windows Vista/7 ||
|| `f6f6` || durch `fdisk` entferntes Betriebssystem ||
|| `fa33` || Windows XP ||
|| `fbc0` || ISOhybrid (Syslinux 3.81) ||
|| `8053` || LILO ||

==== GRUB-Installation in MBR und Bootsektor automatisch aufspüren ====
Die ganze Prozedur kann auch mit einem der folgenden Befehle automatisiert werden. Diesen bitte bei Bedarf in das Terminal kopieren:

 * Die eingehängten Partitionen werden aus der '''/proc/partitions''' ausgelesen und in einer `for`-Schleife an [#Manuelles-Ermitteln-der-GRUB-Version `hexdump`] übergeben und der Byte-Wert gelistet: {{{#!vorlage befehl
for d in $(sed -ne 's/^.*\(sd.*\)/\1/p' /proc/partitions);do echo -e "$d\t ID: $(sudo hexdump -v -s 0x80 -n 2 -e '2/1 "%x" "\n"' /dev/$d)";done;echo -e "\t(G1) 5272/aa75 (G2) 48b4/7c3c/020 (Core) 488/31d2"
}}}

 * Beim nächsten Befehl handelt es sich um eine simple Erweiterung des Einzeilers aus dem Skript [:Archiv/Skripte/GRUB_finden: GRUB finden]. Im wesentlichen setzt sich der Befehl aus den Kommandos `fdisk` und `hexdump` zusammen. Die abschließende `case` Anweisung, wertet die `hexdump` Ausgabe dann aus, das Ergebnis wird dann mittels `echo` im Terminal ausgegeben. `xargs` erlaubt es dabei, die zuvor ermittelte Zeichenkette per Variable an den hinter `-c` in `" "` angegebenen Befehl zu übergeben. Die dazwischen eingebetteten Kommandos `egrep`, `sed` und `awk` dienen dazu, die `fdisk`-Ausgabe alleine auf die Zeichenkette der Form `/dev/sdXY` zurecht zu schneiden: {{{#!vorlage befehl
sudo fdisk -l 2>/dev/null | egrep "Disk /|/dev/" | sed "s#^/dev/#Part /dev/#" | awk '{print $2}' | sed 's/://' | xargs -n1 -IX sudo sh -c "hexdump -v -s 0x80 -n  2 -e '2/1 \"%x\" \"\\n\"' X | xargs -n1 -IY sh -c \"case  \"Y\" in '48b4') echo X: GRUB 2 v1.96 ;; 'aa75' | '5272') echo X: GRUB Legacy ;; '7c3c') echo X: GRUB 2 v1.97 oder v1.98 ;; '020') echo X: GRUB 2 v1.99 ;; *) echo X: Kein GRUB Y ;; esac\""
}}}

= GRUB-2-Umgebung mit der Kommandozeile analysieren =
Mit den Kommandozeilenbefehlen der [:GRUB_2/Shell: GRUB-2-Shell] lassen sich die für einen erfolgreichen Systemstart erforderlichen Informationen und Einstellungen leicht zusammentragen.

{{{#!vorlage Hinweis
Die in diesem Abschnitt aufgeführten Befehle funktionieren in dieser Form nur in der GRUB-2-[:GRUB_2/Shell#Kommandozeile:Kommandozeile] und nicht etwa im [:Terminal:] von Ubuntu.
}}}

== Datenträger-Analyse ==
Um ein System erfolgreich von der Kommandozeile starten zu können, ist es sinnvoll, sich zunächst einen Überblick über die von GRUB 2 erkannten Datenträger zu verschaffen. Der dafür wesentliche Befehl ist `ls`. Verwendet man ihn zusammen mit der Tabulatortaste [[Vorlage(Tasten, tab)]], so erlangt man mit wenigen Befehlseingaben eine Liste der zugreifbaren Datenträger und Partitionen:

 * Datenträger auflisten: {{{#!vorlage Befehl
ls
}}}
 * Partitionen auf einer Festplatte auflisten: {{{#!vorlage Befehl
ls (hdX,}}} und Drücken der Tabulatortaste [[Vorlage(Tasten, tab)]]. `X` muss dabei durch eine Nummer eines Datenträgers ersetzt werden, die zuvor mit `ls` ermittelt wurde.

== Startdateien auffinden ==
Grundvoraussetzung für das Starten des Systems ist, dass man den Datenträger kennt, auf dem sich die Startdateien des jeweiligen Betriebssystems befinden. Diese lassen sich mit dem Befehl `search -f` auffinden. `search` liefert dabei jeweils die GRUB-Bezeichnung des betreffenden Datenträgers als Ergebnis:

 * Datenträger mit Linux-Startdateien ermitteln: {{{#!vorlage Befehl
search -f /vmlinuz
}}}
 * Datenträger mit der Datei '''grub.cfg''' finden: {{{#!vorlage Befehl
search -f /boot/grub/grub.cfg
}}}
 * Datenträger mit Windows-XP-Startdateien ermitteln: {{{#!vorlage Befehl
search -f /ntldr
}}}
 * Datenträger mit Windows-Vista- oder Windows-7-Startdateien ermitteln: {{{#!vorlage Befehl
search -f /bootmgr
}}}

{{{#!vorlage Hinweis
Um die Startdateien auf einer Windows-Partition suchen zu können, muss das Modul ``ntfs`` installiert sein, welches mit dem Befehl ``insmod ntfs`` eingerichtet werden kann.

Wird eine Datei auf dem Datenträger nicht gefunden, so wird eine Fehlermeldung der Form `error: no such device: ...` ausgegeben.
}}}

Der Befehl `search -f` findet keine Namensteile und unterstützt keine Wildcards. Bei verschlüsselten Systemen müsste man beispielsweise nach {{{#!vorlage Befehl
search -f /vmlinuz-4.4.0-45-generic
}}} suchen, da der Link vmlinuz sich nicht auf der unverschlüsselten Boot-Partition befindet. 

Man kann aber mit Hilfe des Befehls `ls` und  Drücken der Tabulatortaste [[Vorlage(Tasten, tab)]] sich den jeweiligen Verzeichnisinhalt anzeigen lassen. Ein {{{#!vorlage Befehl
ls (hd0,1)/
}}} gefolgt von 2 x  [[Vorlage(Tasten, tab)]] zeigt alle vorhandenen Dateien und Verzeichnisse auf '''/dev/sda1'''. So kann man auch den kompletten Namen der vmlinuz-Datei ermitteln.

== GRUB-2-Umgebungsvariablen überprüfen ==
Die den Variablen in der GRUB-2-Umgebung derzeit zugewiesenen Werte können mit Ausführen von

{{{#!vorlage Befehl
set
}}}
überprüft werden. Für den Systemstart sind dabei in erster Linie die Werte von `root` und `prefix` von Bedeutung. Mit dem Befehl {{{#!vorlage Befehl
help
}}}
kann man sich eine Liste aller Befehle in der Grub-Shell anzeigen lassen. Mit dem Befehl{{{#!vorlage Befehl
pager=1
}}}
sorgt man dafür, dass jeweils am Ende einer Bildschirmseite die Ausgabe angehalten wird, so dass die ersten Zeile nicht ungelesen aus dem Bild rollen.

= Umfassende Analyse mittels Boot Info Script =
Alle möglichen Informationen rund um das Booten können auch bequem automatisch mittels des 
[github:arvidjaar/bootinfoscript: Boot Info Script] {en} zusammengetragen werden.

Das Skript kann aus den ''universe''-Quellen installiert werden: [3]
{{{#!vorlage Paketinstallation
boot-info-script, universe
cl-awk, universe, für komplexere Verarbeitungsfähigkeiten (nur bis 18.10)
}}}

Gestartet wird die Analyse mit folgendem Befehl: [2]
{{{#!vorlage Befehl
sudo bootinfoscript
}}}

{{{#!vorlage Hinweis
Dabei wird im aktuellen Verzeichnis das Ergebnis in einer Datei '''RESULTS.txt''' gespeichert. Diese Datei ist gemeint, wenn im Forum ''die Ausgabe des [:GRUB-Umgebung_analysieren/#Umfassende-Analyse-mittels-Boot-Info-Script:Boot-Info-Scripts] im [:Forum/Syntax#Syntaxelemente:Codeblock] posten'' gewünscht wird. Beachte: in dieser Datei ist auch der Inhalt der Datei(en) [:fstab: /etc/fstab]  aller betrachteter Partitionen enthalten, den Inhalt in '''RESULTS.txt''' daher vorher anpassen, sofern kritische Informationen wie z.B. Credentials bei der [:/fstab/#Netzwerk-Freigaben:] dort enthalten sind.

Mit Rücksicht auf die smartphone-Nutzer sollte man die Datei besser als Anhang hochladen.

Seit Focal Fossa wird diese Datei in '''/root/''' abgelegt, man kann sie leicht mit `sudo mv /root/RESULTS.txt ~/` in das einfacher zugängliche home-Verzeichnis der users verschieben.
}}} 

= Links =
 * [:GRUB_2: GRUB-2-Übersicht]
 * [:GRUB_2/Problembehebung: GRUB-2-Probleme und Lösungen]
 * [:GRUB_2/Installation: GRUB-2-Installation]
 * [:GRUB_2/Konfiguration: GRUB-2-Konfiguration]
 * [:GRUB_2/Skripte: GRUB-2-Skripte]
 * [:GRUB_2/Reparatur: GRUB-2-Reparatur]
 * [:GRUB_2/Shell: GRUB-2-Shell]
 * [:GRUB_2/Aussehen: GRUB 2 optisch anpassen]
## * [:Archiv/GRUB_2/Terminalbefehle: GRUB-2-Terminalbefehle]
 * [:GRUB_2/Grundlagen: GRUB-2-Grundlagen]
 * [github:arvidjaar/bootinfoscript: Boot Info Script] {en}

#tag: System, Bootloader