Suffixe für BYTES¶

Wie oben bereits erwähnt wird die Größe der Zahl BYTES standardmäßig in Byte interpretiert. Diese kann durch Hinzufügen von Suffixes geändert werden.

Gemäß dem in der Tabelle aufgezeigten Schema gibt es auch die Suffixe TB, T, PB, P, EB, E, ZB, Z, YB, Y - für alle, die wirklich große Datenmengen kopieren müssen.

Die gleichen Suffixe gelten auch für BLOCKS, d.h. z.B. mit count=1K werden 1024 Blöcke gelesen/geschrieben, mit count=1MB 1000000 Blöcke, usw.

Einige allgemeine Beispiele¶

Im Folgenden ein paar allgemeine Beispiele für die Syntax und die Optionen von dd:

• Es wird die komplette fünfte Partition von /dev/sda in die erste Partition von /dev/sdb kopiert:

  dd if=/dev/sda5 of=/dev/sdb1 

• Es werden die ersten zehn 1024 Byte großen Blöcke von der ersten Partition von /dev/sdb auf die zweite Partition von /dev/sdc kopiert:

  dd if=/dev/sdb1 of=/dev/sdc2 bs=1K count=10  

• Es werden 2000 Byte große Blöcke von der dritten Partition von /dev/sda auf die vierte Partition von /dev/sda kopiert, wobei beim Einlesen die ersten 50 Blöcke (in diesen Fall 50 * 2000 = 100.000 Byte) übersprungen werden, d.h. der Lesevorgang fängt bei Byte 100.001 an:

  dd if=/dev/sda3 of=/dev/sda4 ibs=2KB obs=2KB skip=50 

Live USB-Stick erstellen¶

Mit dd lässt sich auch auf einfache Art und Weise ein Live USB-Stick (als Ersatz für eine Live-DVD/CD) erstellen.

Zum „brennen“ des ISO-Abbilds auf den USB-Stick muss man dessen Gerätedatei (so etwas wie beispielsweise /dev/sdc) kennen. Diesen kann man mit folgender Prozedur ermitteln:

1. Man wartet nach dem Start des Betriebssystems einige Minuten und startet dann ein Terminal^[1].

2. Dann erst steckt man den zu beschreibenden USB-Stick ein.

3. Im Terminal führt man diesen Befehl aus:

   ls -lt /dev/sd* | head 

   Man erhält eine Ausgabe der Gerätedateien, die jüngsten angelegten gehören zum USB-Stick. Mindestens sollte eine Datei nach dem Muster /dev/sdx (der Kleinbuchstabe „x“ variiert je nach Situation) angezeigt werden; eventuell auch eine oder mehrere weitere nach dem Muster /dev/sdxN mit Ziffer(n) am Ende, diese gehören zu bereits angelegten Partitionen auf dem Stick.
   Es ist auch möglich, dass der Datenträger nicht vom SCSI/SATA-Treiber, sondern vom NVMe-Treiber verwaltet wird – dann muss man natürlich nach Gerätedateien mit dem Muster /dev/nvme* suchen.

Diese Anleitung verwendet im folgenden /dev/sdX bzw. /dev/sdXN, vor Ausführung der folgenden Befehle müssen diese Bezeichnungen durch die selbst ermittelten ersetzt werden!

Der Stick wird von Ubuntu beim Einstecken meist automatisch eingehangen, deshalb müssen dessen Dateisysteme zuerst ausgehangen werden (aber bitte nicht auswerfen oder "sicher entfernen"). Dies kann über die GUI erfolgen oder mit diesem Befehl, der für jede Partition angewendet werden muss:

sudo umount /dev/sdXN     # X und N individuell ersetzen! 

Zuletzt muss man noch bei Sticks ohne Partitionstabelle den Stick selbst aushängen:

sudo umount /dev/sdX      # X individuell ersetzen! 

Die beiden Befehle zum Aushängen können Fehler werfen, wenn zwar die Partitionen existieren, aber nicht formatiert sind; man kann diese ignorieren.

Wenn der Stick eine GPT-Partitionstabelle (mit Backup-Tabelle am Ende des Speicherbereichs) aufweist, sollte man diese mit gdisk (Abschnitt „sgdisk“) entfernen:

sudo sgdisk -Z /dev/sdX     # X individuell ersetzen! 

Nach diesen Vorbereitungen kopiert der nächste Befehl dann das Live-Medium-Abbild auf den Stick. Alle Daten auf dem Stick werden dabei überschrieben oder mindestens unzugänglich. Ein weiteres Hinzufügen von Dateien darauf ist nicht möglich.

sudo dd if=NAME_ISO-ABBBILD of=/dev/sdX bs=4M status=progress conv=fdatasync 

Dabei ist natürlich für NAME_ISO_ABBILD der eigene Dateiname einzusetzen.

Dabei beachten, dass statt /dev/sdX die richtige Geräte-Datei zum mit of= bezeichneten Ziel angegeben wird (z.B. /dev/sdc) und nicht eine zu einer Partition (z.B. sdc1).

Den Parameter bs=4M kann man auch weglassen, aber er beschleunigt den Kopiervorgang und verlängert die Lebensdauer des Flash-Speichers. Weitere Tipps zu bootbaren USB-Medien findet man im Artikel Live-USB.

Festplatte klonen¶

Der folgende Befehl klont (kopiert) die komplette Festplatte /dev/sda inklusive aller Partitionen, MBR und Partitionstabelle auf die eine zweite Festplatte /dev/sdb:

dd if=/dev/sda of=/dev/sdb 

Eine miserable Transfergeschwindigkeit bei großen Festplatten sollte hier mit "bs" zb "bs=1M" vermieden werden, solange die Festplatte keine defekten Blöcke hat. Standardmäßig wird mit 512 Bytes gelesen, bei defekten Blöcken wäre ein "bs=4K" zu empfehlen.

Komprimiert man ein solches Festplattenimage, wie im folgenden Absatz beschrieben, noch zusätzlich mit gzip, so sollte man vorher die Ausgabe von fdisk -l speichern und mit der gesicherten Imagedatei zusammen aufheben. Alternativ kann man die Startpositionen der Partitionen auch – sehr zeitaufwändig – aus dem gepackten Image auslesen.

Festplatte (sicher) löschen¶

Der folgende Befehl löscht die komplette Festplatte /dev/sdX durch Überschreiben mit Nullen:

dd bs=1M if=/dev/zero of=/dev/sdX 

Der folgende Befehl löscht die komplette Festplatte /dev/sdX durch Überschreiben mit Zufallsdaten:

dd bs=1M if=/dev/urandom of=/dev/sdX 

Partitionen klonen¶

Der folgende Befehl klont (kopiert) die komplette Partition /dev/sda1 auf die Partition /dev/sdb1:

dd if=/dev/sda1 of=/dev/sdb1 

Man soll sich im Klaren sein, dass dabei alle Partitionsattribute dupliziert werden (Größe, UUID, Label). Alle Geräte mit den dazugehörigen Informationen kann man auflisten:

sudo blkid 

Wenn die Ziel-Partition größer als die Quelle ist, kann man das Zielfilesystem auf die gesamte Partition ausdehnen:

sudo resize2fs /dev/sdb1 

UUID neu setzen:

sudo tune2fs -U random /dev/sdb1 

Labels neu vergeben:

sudo e2label /dev/sdb1 newlabel 

Image einer Partition sichern¶

Der folgende Befehl erstellt ein Image von /dev/sda1 in die Datei image_sda1.img, welche im Heimatverzeichnis gespeichert wird:

dd if=/dev/sda1 of=~/image_sda1.img 

Dies ist die schnellste Methode. Oftmals lässt sich viel Speicherplatz einsparen, wenn das Image zugleich komprimiert wird. Dies bedeutet jedoch größeren Zeitaufwand, was kritisch sein kann, wenn Dateien von einem kränkelnden Datenspeicher gerettet werden sollen.

Der folgende Befehl erstellt ein komprimiertes Image der Partition /dev/sda1 und speichert dieses in die Datei image-compress_sda1.img.gz im Heimatverzeichnis. Durch das Weglassen von of im Befehlsaufruf werden die Daten auf die Standardausgabe geschrieben, wo sie dann per Pipe-Operator an gzip weitergeleitet werden:

dd if=/dev/sda1 | gzip > ~/image-compress_sda1.img.gz 

Sofern die zu sichernde Partition nicht verschlüsselt ist, lässt sich die Kompression oft erheblich verbessern, wenn ihr freier Speicherplatz vorab mit Nullen überschrieben wird. Bedenken sollte man, dass eine eventuelle Datenrettung von versehentlich gelöschten Dateien danach unmöglich wird.

Um das so erzeugte komprimierte Image wieder zurückzusichern, kann man folgenden Befehl verwenden:

gzip -cd ~/image-compress_sda1.img.gz | sudo dd of=/dev/sda1 

Dateigröße des Images begrenzen¶

Für den Fall, dass zum Beispiel das Dateisystem des Ziellaufwerkes eine Dateigrößenbeschränkung hat, besteht die Möglichkeit zum Splitten der Imagedatei. Auf einem FAT32-Laufwerk beispielsweise ist die Dateigröße auf 4 GiB (1 GiB = 1024 * 1024 * 1024 Byte) beschränkt.

In folgendem Beispiel wird das Image an split übergeben und in Teile von je 3500 MiB (1 MiB = 1024 * 1024 Byte) gespeichert. Hierbei werden die jeweiligen Teile nummerisch beschriftet.

dd if=/dev/sda1 | split -d -b 3500M - ~/image_sda1.img. 

Zurückgespielt wird dann, indem das Image durch cat automatisch wieder zusammengefügt und an dd übergeben wird.

cat ~/image_sda1.img.* | dd of=/dev/sda1 

⚓︎

MBR: Boot-Loader und Partitionstabelle sichern¶

Der MasterBootRecord (MBR) beherbergt den Boot-Loader, die Partitionstabelle und die MBR-Signatur. Der MBR ist exakt 512 Bytes lang und liegt am Beginn der Festplatte. Der Boot-Loader belegt die ersten 446 Bytes des MBR, dann folgen die Partitionstabelle (64 Bytes) und die MBR-Signatur, und, Achtung, zumindest GRUB 2 nutzt je nach Konfiguration meist noch einige weitere Sektoren im sog. verborgenen Bereich vor der ersten Partition.

Zur Sicherung ist ein geeignetes Medium notwendig. Nutzer einer LiveCD (z. B. Ubuntu Installations-CD) müssen zunächst ein Medium verfügbar machen:

sudo fdisk -l 

zeigt die Bezeichnungen der eigenen Festplatten an und dient als Orientierunghilfe für folgende Kommandos.

Nun erstellt man einen Ordner im Dateisystem der Live-CD und hängt dort eine Partition ein, auf welcher die Sicherung des MBR erstellt wird.

sudo mkdir ~/sda3
sudo mount /dev/sda3 ~/sda3
cd ~/sda3 

Es kann sich hierbei auch um einen USB-Stick, eine Netzwerkfreigabe oder ein anderes Medium handeln, auf welches man jederzeit Zugriff hat. Jetzt kann mit dem eigentlichen Sichern begonnen werden.

Mit dem folgenden Befehlsaufruf würde der Boot-Loader der Festplatte /dev/sda als Datei bootloader_sicherung im aktuellen Verzeichnis gesichert. Die Partitionstabelle (Bytes 446..509) und die MBR-Signatur sind in dieser Sicherung nicht enthalten:

sudo dd if=/dev/sda of=bootloader_sicherung bs=446 count=1 

Der folgende Befehl sichert den gesamten MBR (inklusive Partitionstabelle) der Festplatte /dev/sda als Datei mbr_sicherung im aktuellen Verzeichnis:

sudo dd if=/dev/sda of=mbr_sicherung bs=512 count=1  

Bei installiertem Boot-Manager, z.B. GRUB 2, sollte man ggf. auch den sog. verborgenen Bereich hinter dem MBR, falls dieser (Regelfall) dafür verwendet wird, mitsichern und vorher schauen, wie viele Sektoren vor der ersten Partition frei sind:

sudo fdisk -lu 

Die erste Zahl in der Spalte Anfang zeigt den Startsektor der ersten Partition. Bei heutigen Festplatten beginnt die erste Partition meist bei Sektor 63. Dann schaut man noch wie viele Bytes ein Sektor hat – meist 512 – und passt den Befehl entsprechend an:

sudo dd if=/dev/sda of=mbr+grub_sicherung bs=512 count=63  

Die Partitionen von SSDs sollten an ganzen Megabytes ausgerichtet sein. Also sollte die erste Partition einer SSD bei 1 MiB (meist 2048 Sektoren ⋅ 512 Bytes) beginnen und der Befehl lautet

sudo dd if=/dev/sda of=mbr+grub_sicherung bs=1M count=1 

Eine Sicherung des Boot-Loaders wird mit

dd if=bootloader_sicherung of=/dev/sda bs=446 count=1 

zurückgespielt. Dieses Kommando kann auch unter Verwendung einer kompletten Sicherung des MBR bzw. obiger mbr+grub_sicherung verwendet werden: Es wird nur der Boot-Loader (Bytes 0..445) wiederhergestellt, die momentane Partitionstabelle (Bytes 446..509) und die MBR-Signatur bleiben dann in jedem Fall erhalten.

Will man den kompletten MBR (also inklusive Partitionstabelle) zurücksichern, so lautet der Befehl wie folgt:

dd if=mbr_sicherung of=/dev/sda bs=512 count=1 

Will man im Fall eines installierten Boot-Managers zusätzlich auch diesen (falls im sog. verborgenen Bereich hinter dem MBR abgelegt) zurücksichern (unter Erhalt des zuvor rückgesicherten Boot-Loaders und der Partitionstabelle), so lautet der Befehl wie folgt (falls die erste Partition bei Sektor 63 beginnt, siehe detaillierteren Hinweis weiter oben):

dd if=mbr+grub_sicherung of=/dev/sda bs=512 skip=1 seek=1 count=62 

⚓︎

Mit dd erstellte Images einbinden¶

dd if=/dev/sda1 of=~/loop_image.img 

sudo mkdir /media/loop_mount 

sudo mount -o loop ~/loop_image.img /media/loop_mount 

sudo umount /media/loop_mount 

sudo fdisk -l /Pfad/zum/Image.img 

Platte /Pfad/zum/Image.img: 0 MByte, 0 Byte
255 Köpfe, 63 Sektoren/Spuren, 0 Zylinder, zusammen 0 Sektoren
Einheiten = Sektoren von 1 × 512 = 512 Bytes
Disk identifier: 0xd53d826f

    Gerät            boot. Anfang      Ende         Blöcke     Id  System
/Pfad/zum/Image.img1   *          63   104872319    52436128+   7  HPFS/NTFS
Partition 1 hat unterschiedliche phys./log. Enden:
     phys=(1023, 254, 63) logisch=(6527, 254, 63)
/Pfad/zum/Image.img2       104872320   109065284    2096482+   82  Linux Swap / Solaris
Partition 2 hat unterschiedliche phys./log. Anfänge (nicht-Linux?):
     phys=(1023, 0, 1) logisch=(6528, 0, 1)
Partition 2 hat unterschiedliche phys./log. Enden:
     phys=(1023, 254, 63) logisch=(6788, 254, 63)
/Pfad/zum/Image.img3       109065285   156296384    23615550   83  Linux
Partition 3 hat unterschiedliche phys./log. Anfänge (nicht-Linux?):
     phys=(1023, 0, 1) logisch=(6789, 0, 1)
Partition 3 hat unterschiedliche phys./log. Enden:
     phys=(1023, 254, 63) logisch=(9728, 254, 63)

sudo mkdir /media/loop_mount # Verzeichniss anlegen
sudo mount -o loop,offset=55841425920 /Pfad/zum/Image.img /media/loop_mount 

sudo umount /media/loop_mount 

Image im Netzwerk speichern¶

Ein mit dd erstelltes Image muss nicht zwangsläufig lokal gespeichert werden, sondern kann auch auf einen anderen Rechner im Netzwerk gesichert werden. Im folgenden Beispiel wird mit dd ein Image von /dev/sda1 erstellt, welches dann ssh-verschlüsselt auf den Rechner mit der IP-Adresse 192.168.0.100 übertragen und dort im Verzeichnis /home/BENUTZER in der Datei image_sda1.img gespeichert wird. Damit dies funktioniert, muss "BENUTZER" ein Benutzerkonto auf dem entsprechenden Rechner haben und man selbst die notwendigen Rechte, um dort zu schreiben. Der Befehlsaufruf lautet:

dd if=/dev/sda1 | gzip -9 - | ssh user@192.168.0.100 "cat > /home/BENUTZER/image_sda1.img.gz" 

ssh user@192.168.0.50 "cat /home/user/image_sda1.img.gz" | gunzip -c - | dd of=/dev/sda1 

dd if=/dev/sda bs=4k | gzip -9 - | ncftpput -c -V -u FTPUSER -p FTPPASSWORT FTPSERVER /FTPPATH/NAME.img.gz  

ncftpget -c -V -u FTPUSER -p FTPPASSWORT FTPSERVER /FTPPATH/NAME.img.gz | gunzip -c - | dd of=/dev/sda bs=4k 

Fortschrittsanzeige¶

Sehr häufig wird eine Fortschrittsanzeige gewünscht, um den Status und die verbleibende Restdauer einer Aktion mit dd nachvollziehen zu können.

dd if=/dev/XXX of=/dev/XXX status=progress 

ps -a 

kill -USR1 <prozessnummer> 

dd if=/dev/XXX of=/dev/XXX & ddpid=$! ; while [ $(ps -ao pid | grep $ddpid) ]; do kill -SIGUSR1 $ddpid; sleep 10; done 

pkill -USR1 -x dd 

dd if=/dev/XXX of=/dev/XXX & while [ ! $(pkill -USR1 -x dd) ]; do sleep 10 ; : ; done 

watch -n10 pkill -USR1 -x dd