Anlegen eines eigenen Skriptes¶

Zunächst muss ein eigenes Skript angelegt werden. Dazu legt man mit einen Editor ^[3] eine Datei mit dem Namensschema "XX_Eigenes_Skript" vorzugsweise im eigenen Homeverzeichnis an. Dabei muss die Bezeichnung - wie unter Konfiguation von GRUB 2 dargestellt - den eigenen Bedürfnissen entsprechend angepasst werden.

Nachdem das Skript inhaltlich den eigenen Vorstellungen entspricht, muss man diese Datei vor dem Kopieren mit den erforderlichen Rechten ^[4] versehen und die Ausführbarkeit einstellen.

Jetzt kann man diese Datei im Terminal ^[1] mit:

sudo cp -f <meine Datei> /etc/grub.d/ 

kopieren und sich im Terminal ^[1] mit:

sudo grub-mkconfig 

das Ergebnis anzeigen lassen.

Allgemeines Beispiel¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#! /bin/sh -e

echo "Füge Eintrag für Lucid Lynx ein"  >&2

cat << EOF
menuentry "Ubuntu" --class ubuntu --class gnu-linux {
        recordfail
	savedefault
	insmod ext2
	set root='(hd0,msdos3)'
	search --no-floppy --fs-uuid --set=root ae875d31-cc84-4349-95d7-01a82ad76d61
	linux	/vmlinuz root=UUID=ae875d31-cc84-4349-95d7-01a82ad76d61 ro ${GRUB_CMDLINE_LINUX_DEFAULT}
	echo  Lade aktuellen Kernel von ${GRUB_DEVICE}... 
	initrd	/initrd.img
	echo  Lade und Initiere RAM-Image von ${GRUB_DEVICE}...
}
EOF

Kernel-Images¶

Ein Kernel-Menü-Eintrag ist der Standard-Menü-Eintrag unter GRUB 2, um ein Linux-System zu booten. Dazu wird der Pfad zum entsprechenden Kernel-Image - der das Starten des Systems einleitet - angegeben. Grundsätzlich werden Kernel-Einträge automatisch über das Skript 10_linux für die aktuelle Distribution und 30_os_prober für andere auf dem Computer installierte Linux-Distributionen gesucht und erstellt.

Sollte es notwendig sein, so kann man einen solchen Eintrag auch manuell erstellen:

Beispiel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#! /bin/sh -e
echo "Adding Saucy Salamander entry" >&2
 cat << EOF
menuentry "Ubuntu, mit Linux 3.11.0-15-generic" {
insmod ext2
set root='(hd0,msdos3)'
search --no-floppy --fs-uuid --set=root d3afdd1-045a-490f-b7ba-86c0c2d8c500
       linux /boot/vmlinuz-3.11.0-15-generic root=UUID=d3afdd1-045a-490f-b7ba-86c0c2d8c500 ro quiet splash
       initrd /boot/initrd.img-3.11.0-15-generic 
}
EOF

Liegt das Zielsystem auf einem externen Datenträger wie z.B. einer USB-HDD, so ist zu obigem Eintrag zusätzlich direkt unter der Zeile menuentry die Zeile 3 einzutragen:

1
2
3
4
5

....
menuentry "Ubuntu, auf externer Festplatte" {
insmod usb
insmod ext2
....

damit die folgenden Daten richtig ausgelesen werden können. Das externe Medium muss aber grundsätzlich vom BIOS erkannt und ausgelesen werden können. Insbesondere einige USB 3.0-Ports haben damit in diesem frühen Zeitpunt noch Probleme.

Anzeige in der Menüzeile¶

Für Ubuntu wird aufgrund der System-ID als Anzeige im Grubmenü immer "Ubuntu" verwendet, auch wenn es sich z.B. um das Derivat "Lubuntu" handelt. Dieser Umstand ist für viele Benutzer unbefriedigend. Um diese Anzeige auf das wirkliche Derivat zu bringen, kann man nachfolgende Veränderungen vornehmen:

#GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_DISTRIBUTOR="Lubuntu"

1
2
3
4
5
6
7
8

#!/bin/sh -e
[ "$GRUB_DISTRIBUTOR" ] || exit;
[ "$GRUB_DISTRIBUTOR" = "Ubuntu" ] && exit
echo "OS-Bezeichnung = $GRUB_DISTRIBUTOR"  >&2;
request_file=/etc/grub.d/10_linux;
if grep -r 'Ubuntu|Kubuntu' $request_file; then
   sed -i s/Ubuntu\|Kubuntu/$GRUB_DISTRIBUTOR/g $request_file;
fi;

sudo grub-mkconfig 

sudo update-grub 

LVM und RAID¶

Ein Fortschritt von GRUB 2 ist, dass die Informationen für ein Betriebssystem von einem RAID-Verbund oder LVM sowie eine Kombination aus beiden, direkt ausgelesen werden kann.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#! /bin/sh -e
echo "Füge eigene Menü-Option Saucy Salamander ein" >&2
 cat << EOF
menuentry "Ubuntu, mit Linux 3.11.0-15-generic" {
	insmod raid
	insmod mdraid
	insmod lvm
	insmod ext2
	set root='(vg_1-boot)'
	search --no-floppy --fs-uuid --set=root 11992cde-b1d9-4392-bcc4-13c2ce8702aa
	linux	/vmlinuz-3.11.0-15-generic root=/dev/mapper/vg_1-root ro quiet splash
	initrd	/initrd.img-3.11.0-15-generic
}
EOF

Symlink zum Wurzelverzeichnis¶

Ein symlink-Menü-Eintrag startet wie der Kernel-Menü-Eintrag auch einen Linux Kernel. Dabei wird anstelle einer kompletten Pfad- und Kernel-Bezeichnung

1
2

       linux   /boot/vmlinuz-2.6.32-25-generic root=UUID=41b9df5e-....-...
       initrd  /boot/initrd.img-2.6.32-25-generic 

der Pfad als Symlink zum Kernel angegeben. Dieser Symlink befindet sich direkt im Wurzelverzeichnis und verweist im folgenden Beispiel auf den jeweils aktuellen Kernel im Verzeichnis /boot.

1
2

       linux /vmlinuz root=UUID=41b9df5e-...-...
       initrd /initrd.img

Symlink zur Boot-Partition¶

Befindet sich das Verzeichnis /boot auf einer separaten Partition, so greift die Vorgehensweise unter Symlink zum Wurzelverzeichnis nicht. Dazu muss dann das folgende Skript (mit z.B. mit 09_K_aktuell bezeichnet) zwischen geschaltet werden:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#!/bin/sh -e
# Hiermit wird bei einem 'update-grub' der aktuelle Kernel
# intern auf eine einheitliche Form innerhalb '/boot' verlinkt.

SETZE_LINK () {
rm -f ${SUCHE_WAS};
list=$( for i in ${SUCHE_WAS}-* ; do
    echo -n "$i " ; done )
[ "x$list" = "x" ] && exit 
linux=$( version_find_latest $list )
ln -s "$linux" ${SUCHE_WAS} > /dev/null
echo "Link für $linux eingefügt"  >&2;
}

. /usr/lib/grub/grub-mkconfig_lib
cd /boot;

SUCHE_WAS="vmlinuz" && SETZE_LINK;
SUCHE_WAS="initrd.img" && SETZE_LINK;

Nun wird nach jedem Kernelupdate bzw. nach der Eingabe in das Terminal von:

sudo update-grub 

ausschließlich der jeweils aktuelle (höchste) Kernel als Symlink im Verzeichnis für die Images angeboten.

Configfile¶

Mit einem configfile-Menü-Eintrag kann man GRUB 2 anweisen, die Menü-Konfiguration zur Laufzeit aus einer anderen Datei als der standardmäßigen /boot/grub/grub.cfg zu entnehmen. Das ist z.B. dann sinnvoll, wenn man eine weitere Distribution auf dem Computer installiert hat, die auch GRUB 2 als Bootloader einsetzt oder aber auch einfach nur für Experimente.

Beispiel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#! /bin/sh -e
echo "Adding Precise Testing menuentry" >&2
 cat << EOF
menuentry "Nachladen Precise grub.cfg von /dev/sdb1" {
        insmod ext2
        set root='(hd1,1)'
	search --no-floppy --fs-uuid --set=root 11992cde-b1d9-4392-bcc4-13c2ce8702aa        
        configfile  /boot/grub/grub.cfg
}
EOF

Hier wird die /boot/grub/grub.cfg einer Installation eingelesen, die sich auf der ersten Partition der zweiten Festplatte im Computer befindet. Mit der Esc -Taste kann man wieder in das Menü zurück wechseln, von dem aus aufgerufen wurde.

Submenü einrichten¶

Man kann die Funktion Submenü auch für seine eigenen Zwecke benutzen.

Um das zu realisieren, kann man verschiedene Wege beschreiten - wichtig ist nur, dass man die relevanten Menüpunkte (Skripte) zusammenfasst und vor diesen die Sequenz

1

submenu 'Meine Menüsammlung' {

im ersten Skript einbringt und am Ende der Sammlung noch eine geschweifte Klammer hinter dem letzten Skript zusätzlich anordnet. Oder man macht das z.B.: jeweils in einem Skript, dass dann in der Zählung entsprechend angelegt wird:

• 12A_submenu_start mit:

1
2
3
4

#! /bin/bash -e
cat << EOF
submenu 'Meine Menüsammlung' {
EOF

• 13_... bis 16_... Skriptesammlung

• 19A_submenu_abschluss mit:

1
2
3
4

#! /bin/bash -e
cat << EOF
}
EOF

Beispiel BIOS-Modus¶

In der Regel wird das Windows bei der Installation von Ubuntu automatisch gefunden und der Menüeintrag richtig erstellt. Mit dem folgenden Skript kann man Probleme oder Besonderheiten umgehen, um Windows zu starten.

Man muss als erstes ermitteln, auf welcher Partition der Bootmanager (die Datei bootmgr) von Windows sich befindet. Das kann je nach Art der Installation von Windows auf der separaten Partion mit der Bezeichnung

• "System-reserviert"

oder auf einer normalen "NTFS"-Partition sein. Diese sei beispielhaft /dev/sda1. Mit dieser Information ermittelt man die UUID mit:

sudo grub-probe -t fs_uuid -d /dev/sda1 

Diese UUID wird nun in das folgende Skript in Zeile 7 übernommen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#! /bin/sh -e
echo "Füge einen Starteintrag für Windows ein" >&2
cat << EOF
menuentry "Microsoft Windows im BIOS-Modus starten" {
        insmod part_msdos
	insmod ntfs
	search --no-floppy --fs-uuid --set=root eaf815c4f8159045
        parttool \${root} hidden-
	drivemap -s (hd0) \${root}
	chainloader +1
}
EOF

Beispiel EFI-Modus¶

In der Regel wird ein EFI-Windows bei der Installation von Ubuntu (bis Version Raring Ringtail (13.04)) nicht automatisch gefunden und der Menüeintrag fehlt deshalb im Grubmenü. Das ist kein , sondern konzeptionell so gewollt! Läßt sich das Windows aber über das EFI-Menü des Rechners starten, dann kann man das auch in das Grubmenü einbringen und von hier aus das Windows starten.

Dabei ist es wichtig, dass das Ubuntu im EFI-Modus gestartet wurde, von dem aus das Windows aufgerufen werden soll! Dazu gibt man in ein Terminal ^[1] ein:

sudo parted -l 

und sucht in der Ausgabe unter

• "Flags" nach

  • "EFI system partition"

(oder einem sinngemäß vergleichbaren Eintrag) und überprüft das Vorhandensein einer EFI-Partition. Diese Partition wird zur Erstellung des folgenden Skriptes als Ziel verwendet und wird z.B. als 29_windows lauffähig in das Verzeichnis /etc/grub.d abgelegt und sollte nach einen

sudo update-grub 

einen Eintag im Grubmenü zum Starten des Windows bereitstellen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#!/bin/bash
# EFI-Partition suchen und auswerten
if [ -f /boot/efi/EFI/Microsoft/Boot/bootmgfw.efi ]; then
	EFI_UUID=$( grub-probe -t fs_uuid /boot/efi/EFI )
	echo "Menüeintrag für Windows eingefügt" >&2

cat <<EOF
menuentry "Windows 8 Pro (UEFI)" {
	insmod fat
	insmod chain
	search --no-floppy --fs-uuid --set=root ${EFI_UUID}
	chainloader /EFI/Microsoft/Boot/bootmgfw.efi
}
EOF
fi

Beispiel Ubuntu-Iso¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#! /bin/sh -e
export GRUB_LOOPBACK_ISO_FILE="/Pfad_zum_ISO/ubuntu-12.04-desktop-i386.iso"
echo "Adding Live CD entry" >&2

 cat << EOF
menuentry 'Precise Pangolin Live CD i386-ISO booten' {
insmod part_msdos
insmod ntfs
insmod ext2
search -n -f --set=root ${GRUB_LOOPBACK_ISO_FILE}
    loopback loop ${GRUB_LOOPBACK_ISO_FILE}
    linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=${GRUB_LOOPBACK_ISO_FILE} \
        ${GRUB_CMDLINE_LINUX_DEFAULT} ${GRUB_CMDLINE_LINUX} quiet splash --
    initrd (loop)/casper/initrd.lz
}
EOF

Die Bezeichnung loop im obigen Beispiel als Identmerkmal ist frei wählbar, sollte aber keine Umlaute enthalten! Durch dieses Skript wird ein Menü-Eintrag generiert, der das mittels /Pfad_zum_ISO/ubuntu-xyz-i386.iso ausgewiesene ISO-Image auf den Festplatten sucht und als Live-CD bootet. Der /Pfad_zum_ISO/ darf im übrigen nicht das Laufwerk enthalten, da die Zeile

 search -n -f --set=root ${GRUB_LOOPBACK_ISO_FILE} 

auf allen verfügbaren Laufwerken nach dem ${GRUB_LOOPBACK_ISO_FILE} sucht, und das Laufwerk, auf dem die Datei liegt, als /root setzt. Außerdem darf der Pfad auch keinen logischen Link beinhalten, weil grub diesem nicht folgen kann.

Mit diesen Einstellungen werden die Desktop- und die Tastatur-Einstellungen gleich auf Deutsch gestartet. Es können auch weitere Parameter übergeben werden. Auch der Eintrag für das ISO-Image kann alternativ entsprechend eigene Variablen direkt eingebracht werden:

Dafür kann dann die relevante Zeile 2 im obigen Skript entfallen. Wenn man das Live-System nicht nur benutzen, sondern auf der Festplatte installieren möchte, muss man vor der Installation das Image mittels

sudo umount -l -r -f /isodevice 

aushängen, da sonst die Installation nicht möglich ist. Da das /isodevice ansonsten in Benutzung ist, kann es nicht automatisch von der Installtionsroutine ausgehängt werden.

Beispiel Lubuntu 14.10 64bit¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#! /bin/sh -e

export ISOFILE="/Pfad_zum_ISO/lubuntu-14.10-desktop-amd64.iso"
echo "Found ISOFILE image: ${ISOFILE}" >&2
cat << EOF
menuentry "${ISOFILE}" {
	insmod loopback
	insmod iso9660
	insmod part_msdos
	insmod part_gpt
	insmod ext2
	insmod ntfs
	insmod btrfs
	search -n -f --set=root ${ISOFILE}
	loopback loop ${ISOFILE}
	linux (loop)/casper/vmlinuz.efi boot=casper iso-scan/filename=${ISOFILE} ro noprompt noeject noplymouth 
	initrd (loop)/casper/initrd.lz
	}
EOF

Beispiel Parted Magic Iso¶

1
2
3
4
5
6
7
8
9

#! /bin/sh -e
echo "Adding Parted Magic ISO entry" >&2
 cat << EOF
menuentry "Parted Magic - ISO" {
       loopback loop (hd0,3)/pmagic-4.4.iso
       linux (loop)/pmagic/bzImage isofrom=/dev/sda3/pmagic-4.4.iso edd=off noapic load_ramdisk=1 prompt_ramdisk=0 rw vga=791 sleep=10 loglevel=0 keymap=de
       initrd (loop)/pmagic/initramfs
}
EOF

Dieser Eintrag bootet das Parted Magic-ISO Version 4.4 von der dritten Partition der ersten Festplatte.

Kernel-Boot-Optionen für ISO ermitteln¶

Um ISO-Dateien erfolgreich booten zu können sind - wie man an den langen GRUB_CMDLINE_LINUX bzw. linux-Zeilen in den Beispielen sieht - die richtigen Kernel-Boot-Optionen von entscheidender Bedeutung. Diese sind jedoch von ISO zu ISO unterschiedlich. Die Optionen sind aber stets auf dem ISO erhalten, so dass man diese nur auslesen ^[2] muss, um die Optionen setzen zu können.

In aller Regel befinden sich diese Optionen in der Datei isolinux.cfg, die sich im Verzeichnis /isolinux innerhalb des ISO befindet. Dort kann man auch herauslesen, welche Dateien im ISO die zu ladende Kernel-Datei und Ramdisk enthalten.

Bei den offiziellen Ubuntu ISO-Dateien verzweigt die isolinux.cfg in weitere Dateien, so dass diese Informationen in der txt.cfg im Verzeichnis /isolinux zu finden sind.

Fehler in Grub abfangen¶

Um Fehler abzufangen, die von GRUB_2 erkannt werden können (z.B. dass nach einem Update die Kerneleinträge falsch sind), so bietet sich die nachfolgend beschriebene Prozedur an.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#! /bin/sh -e

if [ ! "x${GRUB_DEFAULT}" = "xsaved"  ] ; then
  if [ "x${GRUB_FALLBACK}" = "x" ] ; then 
     export GRUB_FALLBACK=""
     GRUB_FALLBACK=$( ls /boot | grep -c 'initrd.img' )
     [ ${GRUB_DISABLE_LINUX_RECOVERY} ] || GRUB_FALLBACK=$(( ${GRUB_FALLBACK} * 2 ))
  fi
  echo "fallback modus set to menuentry=${GRUB_FALLBACK}"  >&2

  cat << EOF
  set fallback="${GRUB_FALLBACK}"
EOF

fi

Fehler im Betriebssystem abfangen¶

Fehler im Betriebssystem erkennt GRUB 2 mit der oben beschriebenen Methode nicht, nachdem das Laden der Kerneldateien erfolgreich war.

Will man auftretende Fehler nach diesem Zeitpunkt abfangen, so muss man einen Neustart auf ein Reservesystem umleiten, welches in einer anderen Partition auf demselben Rechner oder einem externem Datenträger liegt.

Angenommen wird das Haupt-System liegt z.B.: auf der ersten Menüposition ("0"), das Reserve-System dagegen auf der zweiten Menüposition ("1").

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#! /bin/sh -e
echo "Menü zum Umleiten und Rückstellen eingefügt"  >&2
cat << EOF
menuentry "Hauptsystem Headless Server (0)" {
	set saved_entry="1"
	save_env saved_entry
	insmod ext2
	insmod raid
	set root='(hd0,2)'
	search --no-floppy --label --set=root ROOT_MAIN
	linux	/vmlinuz root=UUID=ae875d31-cc84-4349-95d7-01a82ad76d61 ro 
	initrd	/initrd.img
}
menuentry "Reservesystem Headless Server (1)" {
	set saved_entry="0"
	save_env saved_entry
	insmod ext2
	insmod raid
	set root='(hd0,3)'
	search --no-floppy --label --set=root ROOT_SAVE
	linux	/vmlinuz root=UUID=43c4345B-0c0a-4df6-8abe-8114b06393b2 ro 
	initrd	/initrd.img
}
EOF

1

    grub-set-default 0 > /dev/null;