[[Vorlage(getestet,general)]] [[Vorlage(Fortgeschritten)]] {{{#!vorlage wissen [:Terminal: Ein Terminal öffnen] [:Pakete installieren: Installation von Programmen] [:Paketquellen freischalten: Bearbeiten von Paketquellen] }}} [[Inhaltsverzeichnis(2)]] [[Bild(Wiki/Icons/terminal.png, 48, align=left)]] `dd` dient zum bit-genauen Kopieren von Festplatten, Partitionen oder Dateien. "Bit-genaues" Kopieren bedeutet, dass der Datenträger Bit-für-Bit bzw. Byte-für-Byte ausgelesen und beschrieben wird, unabhängig von dessen Inhalt und Belegung. `dd` funktioniert grundsätzlich mit allen Dateisystemen auf die Ubuntu / Linux zugreifen kann (z.B. ext2/3, reiserfs, vfat, ntfs etc.). Es funktioniert auch mit CD/DVD-Dateisystemen, allerdings nur für Daten-CDs/DVDs. {{{#!vorlage Warnung * `dd` wird ohne weitere Rückfragen bzw. Sicherheitsabfragen ausgeführt. Bei unachtsamen Aufrufen könnten evtl. vorhanden Daten überschrieben werden! * Bevor man eine Partition oder komplette Platte sichert sollte diese [:Datenträger:ausgehängt werden], um sicherzustellen, dass während des Sicherungsvorgangs keine Daten auf die zu sicherende Platte geschrieben werden. * `dd` sollte auf gar keinen Fall zur Übernahme eines bestehenden Systems auf eine [wikipedia:Solid-State-Drive: SSD] (Solid-State-Drive) genutzt werden, denn dadurch wird die SSD mit unnötigen Schreibprozessen belastet und das [wikipedia:Solid-State-Drive#Alignment_bzw._Ausrichtung: Alignment] wird höchstwahrscheinlich nicht eingehalten. }}} = Installation = Das Programm `dd` ist in jeder Ubuntu-Installation bereits enthalten, und befindet sich dem Paket * '''coreutils''' = Aufruf = Syntaxaufruf für die Verwendung in der Shell [1]: {{{#!vorlage Befehl dd if=Quelle of=Ziel }}} ||``if``|| Steht für "Input File", kann ein komplettes Gerät (z.B. '''/dev/sda'''), eine Partition oder eine Datei sein. || ||``of``|| Steht für "Output File", kann ein komplettes Gerät (z.B. '''/dev/sdb'''), eine Partition oder eine Datei sein. || `dd` kann ohne [:sudo:Root-Rechte] aufgerufen werden. Man benötigt nur dann Root-Rechte, wenn von einem Gerät bzw. einer Partition gelesen bzw. darauf geschrieben werden soll, auf die nur Root Zugriff hat. Beim Lesen von CD/DVDs muss dd grundsätzlich mit Root-Rechten aufgerufen werden. {{{#!vorlage Hinweis * Wird ``if`` bzw. ``of`` weggelassen, so liest dd von der Standardeingabe bzw. schreibt auf die Standardausgabe. Dies ist dann nützlich, wenn dd in Kombination mit dem Pipe-Operator genutzt wird. * dd kann zwar grundsätzlich auch Dateien kopieren, allerdings ist hier in der Regel der Befehl [:cp:] komfortabler. }}} = Optionen = Der Befehl `dd` kennt u.a. die folgenden Optionen: ||<-2 tablestyle="width: 95%;" cellstyle="background-color: #E2C890; text-align: center;"> '''dd - Optionen''' || ||'''Option'''||'''Beschreibung'''|| ||``obs=BYTES``|| Es wird in Blöcken mit der Größe BYTES geschrieben. || ||``ibs=BYTES``|| Es werden Blöcke der Größe BYTES gelesen. || ||``bs=BYTES``|| Es werden Blöcke mit der Größe BYTES gelesen und geschrieben. Wird bs als Option benutzt, so ist ``ibs`` = ``obs`` = ``bs``. || ||``count=BLOCKS``|| BLOCKS gibt an, wie viele Blöcke mit der durch bs / obs / ids festgelegten Größe gelesen und / oder geschrieben werden. || ||``seek=BLOCKS``|| BLOCKS gibt an, wie viele Blöcke der mit ``obs`` oder ``bs`` festgelegten Größe zu Beginn des Schreibvorgangs übersprungen werden. || ||``skip=BLOCKS``|| BLOCKS gibt an, wie viele Blöcke der mit ``ibs`` oder ``bs`` festgelegten Größe zu Beginn des Lesevorgangs übersprungen werden sollen. || ||``status=noxfer``|| Unterdrückt die Ausgabe von Statusinformationen während des Kopiervorgangs. Durch ``kill -SIGUSR1 `` wird der laufende dd manuell dazu veranlasst, Statusinformationen auszugeben. || Für die Angaben ``BYTES`` und ``BLOCKS`` gilt: * ``BYTES`` muss ganzzahlig sein. Ohne weiteres Suffix wird die Größe der Zahl ``BYTES`` in Byte interpretiert. * ``BLOCKS`` muss ganzzahlig sein. Des Weiteren kennt `dd` noch verschiedene andere Optionen, insbesondere zum Konvertieren der Daten zwischen Einlesen und Ausgabe. Diese werden bei "normaler" Benutzung eher selten gebraucht, können aber in den [:man:Manpages] von `dd` nachgelesen werden. {{{#!vorlage Hinweis Wenn man keine Blockgröße angibt verwendet `dd` eine kleine Standardgröße, was den Datentransfer durch den Overhead sehr langsam macht. Insofern ist es empfehlenswert, z.B. ``bs=1M`` anzugeben. }}} == 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. ||<-2 tablestyle="width: 95%;" cellstyle="background-color: #E2C890; text-align: center;"> '''Suffixe für BYTES''' || ||'''Suffix'''||'''Multiplikator'''|| ||``KB``||1000 (d.h. 1KB entspricht 1000 Byte)|| ||``K``||1024 (d.h. 1K entspricht 1024 Byte)|| ||``MB``||1000000 (= 1000 * 1000, d.h. 1MB entspricht 1000000 Byte)|| ||``M``||1048576 (= 1024 * 1024, d.h. 1M entspricht 1048576 Byte)|| ||``GB``||1000000000 (= 1000 * 1000 * 1000, d.h. 1GB entspricht 1000000000 Byte)|| ||``G``||1073741824 (= 1024 * 1024 * 1024, d,h, 1G entspricht 1073741824 Byte)|| 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: {{{#!vorlage Befehl dd if=/dev/sda5 of=/dev/sdb1 }}} * Es werden die ersten zehn 1024 Byte großen Blöcke von der erste Partition von '''/dev/sdb''' auf die zweite Partition von '''/dev/sdc''' kopiert: {{{#!vorlage Befehl 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. {{{#!vorlage Befehl dd if=/dev/sda3 of=/dev/sda4 ibs=2KB obs=2KB skip=50 }}} = Anwendungen = Im folgenden verschiedene Anwendungen für `dd`. == 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''': {{{#!vorlage Befehl dd if=/dev/sda of=/dev/sdb }}} {{{#!vorlage Warnung Es sollte darauf geachtet werden, dass die beiden Festplatten gleich groß sind - oder zumindest das Ziel größer. Falls man plant beide Platten gleichzeitig im selben PC zu betreiben, ist darauf zu achten, dass die [:UUID: UUIDs] der geklonten Platte geändert werden, da es sonst zu Konflikten kommt. }}} Komprimiert man ein solches Festplattenimage, wie im folgenden Absatz beschrieben, noch zusätzlich mit gzip, so sollte man vorher die Ausgabe von fdisk -lu speichern und mit der gesicherten Imagedatei zusammen aufheben. Alternativ kann man die Startpositionen der Partitionen auch - sehr zeitaufwändig - [http://forum.ubuntuusers.de/topic/partitionen-aus-ge-gziptem-dd-image-auslesen-o/ aus dem gepackten Image auslesen.] == Partitionen klonen == Der folgende Befehl klont (kopiert) die komplette Partition '''/dev/sda1''' auf die Partition '''/dev/sdb1''': {{{#!vorlage Befehl dd if=/dev/sda1 of=/dev/sdb1 }}} {{{#!vorlage Warnung Es sollte darauf geachtet werden, dass die beiden Partitionen gleich groß sind. }}} == Image einer Partition sichern == Der folgende Befehl erstellt ein Image von '''/dev/sda1''' in die Datei '''image_sda1.img''', welche im Heimatverzeichnis gespeichert wird: {{{#!vorlage Befehl dd if=/dev/sda1 of=~/image_sda1.img }}} Diese Art der Sicherung ist nicht wirklich zu empfehlen, da die Image-Datei die gleiche Größe wie die gesicherte Partition hat. Daher ist es sinnvoller, das Image zu komprimieren. Der folgende Befehl erstellt ein komprimiertes Image der Partition '''/dev/sda1''' und speichert dieses in die Datei '''image-compress_sda1.img''' 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: {{{#!vorlage Befehl dd if=/dev/sda1 | gzip > ~/image-compress_sda1.img.gz }}} {{{#!vorlage Hinweis Im Regelfall reichen die Standardeinstellungen von gzip aus. Möchte man dennoch die beste Kompressionsstufe, so lautet der zu verwendende Befehl `gzip -9`. Zu beachten ist, dass bei hohen Kompressionsstufen die Dauer deutlich erhöht - teils sogar vervielfacht - wird, während der Speicherverbrauch nur gering abnimmt [1]. Auch wenn das Image von gzip mit der höchsten Kompressionsstufe komprimiert wird, kann die Ausgabedatei unter Umständen trotzdem sehr groß werden. Man sollte also auf ausreichend Platz auf dem Zieldatenträger achten! }}} Um das so erzeugte komprimierte Image wieder zurückzusichern, kann man folgenden Befehl verwenden: {{{#!vorlage Befehl gunzip -c ~/image-compress_sda1.img.gz | sudo dd of=/dev/sda1 }}} == Dateigröße des Images begrenzen== Für den Fall, dass zum Beispiel das [:Dateisystem:Dateisystem] des Ziellaufwerkes eine [:Dateisystem#Weitere-Merkmale: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:split] übergeben und in Teile von je 3500 MiB (1 MiB = 1024 * 1024 Byte) gespeichert. Hierbei werden die jeweiligen Teile nummerisch beschriftet. {{{#!vorlage Befehl dd if=/dev/sda1 | split -d -b 3500M - ~/image_sda1.img. }}} {{{#!vorlage Hinweis Nicht den Punkt hinter sda1.img. vergessen! Dahinter steht dann die Folgenummer der Datei. Das Ergebnis sieht dann in unserem Falle so aus: - image_sda1.img.00 - image_sda1.img.01 - image_sda1.img.02 - image_sda1.img.03 }}} Zurückgespielt wird dann, indem das Image durch [:cat:cat] automatisch wieder zusammengefügt und an dd übergeben wird. {{{#!vorlage Befehl cat ~/image_sda1.img.* | dd of=/dev/sda1 }}} [[Anker(mbr_sichern)]] == MBR: Boot-Loader und Partitionstabelle sichern == Der MasterBootRecord (MBR) setzt sich aus dem Boot-Loader und der Partitionstabelle zusammen. Der MBR ist exakt 512 Bytes lang und liegt am Beginn der Festplatte. Der Boot-Loader belegt die ersten 446 Bytes des MBR und zumindest Grub nutz noch einige weitere Sektoren. Zur Sicherung ist ein geeignetes Medium notwendig. Nutzer einer LiveCD (z. B. Ubuntu Installations-CD) müssen zunächst ein Medium verfügbar machen: {{{#!vorlage Befehl sudo fdisk -lu }}} 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. {{{#!vorlage Befehl 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. {{{#!vorlage Warnung Die Sicherung der Partitionstabelle ist mit Vorsicht anzuwenden, da: 1. bei der Partitionstabelle des MBR nur die primären Einträge gesichert werden. Die Einträge zu den erweiterten, logischen Partitionen fehlen komplett. 1. beim Einsatz einer GPT überhaupt keine Sicherung der Partitionstabelle erfolgt. Außerdem wird der Bootloader in eigene [:GRUB_2/Grundlagen#GPT-Partitionstabelle: Boot-Partitionen] installiert. Um immer auf der sicheren Seite zu sein, empfiehlt es sich nach jeder Partitionsänderung die entsprechenden Tabellen neu zu sichern. Bei der MBR-Partitionstabelle kann man dazu das Programm [:fdisk##Partitionstabelle-sichern:sfdisk] und bei der GUID-Partitionstabelle das Programm [:gdisk##Partitionstabelle-sichern:sgdisk] nutzen. Wer es noch einfacher möchte, der kann das [:Skripte/Partitionstabellen_sichern:Skript Partitionstabellen sichern] dazu nutzen. }}} {{{#!vorlage Hinweis Die folgenden Anweisungen zum sichern des MBR sollten nur als Muster der Möglichkeiten von `dd` verstanden werden. }}} Mit dem folgenden Befehlsaufruf würde der Boot-Loader der Festplatte '''/dev/sda''' als Datei '''bootloader_sicherung''' im aktuellen Verzeichnis gesichert. Die Partitionstabelle ist in dieser Sicherung nicht enthalten: {{{#!vorlage Befehl 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: {{{#!vorlage Befehl sudo dd if=/dev/sda of=mbr_sicherung bs=512 count=1 }}} Bei Grub sollte man auch den sog. verborgenen Bereich hinter dem MBR mitsichern und vorher schauen, wie viele Sektoren vor der ersten Partition frei sind: {{{#!vorlage Befehl sudo fdisk -lu }}} Bei heutigen Festplatten sind das meist die Sektoren 0 - 62 (erste Partition beginnt bei 63), seit Windows-Vista aber auch häufig erst bei Sektor 2048 (von der Sektorgröße der Festplatte abhängig) dann schaut man noch wie viele Bytes ein Sektor hat (meist 512) und passt den Befehl entsprechend an: {{{#!vorlage Befehl sudo dd if=/dev/sda of=mbr_grub_sicherung bs=512 count=63 }}} Eine Sicherung des Boot-Loaders wird mit {{{#!vorlage Befehl dd if=bootloader_sicherung of=/dev/sda bs=446 count=1 }}} zurückgespielt. Dieses Kommando kann auch mit einer kompletten Sicherung des MBRs verwendet werden: Es wird nur der Boot-Loader wiederhergestellt, die momentane Partitionstabelle bleibt unberührt. Will man den MBR (also inklusive Partitionstabelle) zurücksichern, so lautet der Befehl wie folgt: {{{#!vorlage Befehl dd if=mbr_sicherung of=/dev/sda bs=512 count=1 }}} Will man im Fall von Grub auch den sog. verborgenen Bereich hinter dem MBR (also exklusive MBR und Partitionstabelle) zurücksichern, so lautet der Befehl wie folgt: {{{#!vorlage Befehl dd if=mbr_grub_sicherung of=/dev/sda bs=512 skip=1 seek=1 count=62 }}} [[Anker(mount_bsp)]] == Mit dd erstellte Images einbinden == === Image einer Partition einbinden === Ein mit dd erstelltes Image lässt sich als Loop-Device mit dem Befehl [:mount:] einbinden. So kann auf das Image wie auf ein normales Laufwerk zugegriffen werden. Dazu erstellt man als erstes ein Image, hier z.B. vom Device '''/dev/sda1''', gespeichert in der Datei '''loop_image.img''' im Heimatverzeichnis: {{{#!vorlage Befehl dd if=/dev/sda1 of=~/loop_image.img }}} Dann erzeugt man einen Einhängpunkt, z.B. '''/media/loop_mount''': {{{#!vorlage Befehl sudo mkdir /media/loop_mount }}} Jetzt kann man das mit dd erzeugt Image mit '''mount''' einbinden: {{{#!vorlage Befehl sudo mount -o loop ~/loop_image.img /media/loop_mount }}} Nun kann man auf alle Dateien, Verzeichnisse etc. des Images wie auf ein reguläres Laufwerk zugreifen. Nach der Benutzung muss man das Image dann wieder mit '''umount''' aushängen: {{{#!vorlage Befehl sudo umount /media/loop_mount }}} Bei Bedarf kann das (bearbeitete) Image jetzt auch wieder zurück gesichert werden. === Partition aus einem Image der gesamten Platte einbinden === Hat man nicht nur eine Partition, sondern die gesamte Festplatte inclusive MBR gesichert, braucht man den Offset der jeweiligen Partition. Diesen kann man mit dem Befehl {{{#!vorlage Befehl sudo fdisk -l -u /Pfad/zum/Image.img }}} herausfinden. Die Ausgabe sieht bei 3 primären Partitionen ungefähr so aus: {{{ 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) }}} Der Wert hinter der entsprechende Partition unter Anfang, ist der Offset, dieser muss jedoch noch mit der weiter oben angegebenen Sektorgröße multipliziert werden (hier 512). Der Offset für die 3. Partition wäre also 109065285 * 512 = 55841425920. Nun Folgt der Mountbefehl mit dem entsprechenden Offset (hier wieder am Beispiel der 3. Partition): {{{#!vorlage Befehl sudo mkdir /media/loop_mount # Verzeichniss anlegen sudo mount -o loop,offset=55841425920 /Pfad/zum/Image.img /media/loop_mount }}} Zum Schluss wird das Image wieder freigegeben mit: {{{#!vorlage Befehl sudo umount /media/loop_mount }}} Des Weiteren gibt es ein [:mount#Festplatten-Image:fertiges Skript], mit dem mit dd erstellte Image-Dateien komfortable eingebunden werden können. == 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: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: === gzip-komprimiert und ssh-verschlüsselt === {{{#!vorlage Befehl dd if=/dev/sda1 | gzip -9 - | ssh user@192.168.0.100 "cat > /home/BENUTZER/image_sda1.img.gz" }}} Um das Image zurückzusichern (z.B. auf den Rechner mit der IP-Adresse ``192.168.0.50``), gibt man folgenden Befehl ein: {{{#!vorlage Befehl ssh user@192.168.0.50 "cat /home/user/image_sda1.img.gz" | gunzip -c - | dd of=/dev/sda1 }}} === bzip2-komprimiert und nicht verschlüsselt === Alternativ mit bzip komprimiert, aber im Transfer nicht: Auf dem Zielrechner {{{#!vorlage Befehl netcat -l -p 5555 | dd of=/home/user/image_sda1.img bs=16065b }}} Auf dem Quellrechner {{{#!vorlage Befehl dd if=/dev/sda1 bs=16065b | pv | bzip2 -1 | netcat ZielIP 5555 }}} === ftp mit gzip Komprimierung und nicht verschlüsselt === Erstellen eines Images über ftp {{{#!vorlage Befehl dd if=/dev/sda bs=4k | gzip -9 - | ncftpput -c -V -u FTPUSER -p FTPPASSWORT FTPSERVER /FTPPATH/NAME.img.gz }}} Und zum Einspielen vom erstellten Image {{{#!vorlage Befehl ncftpget -c -V -u FTPUSER -p FTPPASSWORT FTPSERVER /FTPPATH/NAME.img.gz | gunzip -c - | dd of=/dev/sda bs=4k }}} ==Den Fortschritt von dd abfragen== ===Einmalige oder regelmäßige Abfrage mittels senden des Signals `-USR1` === Informationen zum ermitteln von Prozessen siehe [:Shell/ps: ps], [:pgrep:] oder [:Shell/pidof: pidof] und zum senden von Signalen [:Shell/kill: kill], [:pkill:] oder [:Shell/killall: killall]. Wenn das dd-Kommando einmal abgesetzt wurde, wünscht man sich bei größeren Kopiervorgängen eine Kontrollmöglichkeit über den Fortschritt. Dies erreicht man indem man dem `dd`-Prozess das Signal `-USR1` sendet. ==== mit `ps` und `kill` ==== In einem zweiten Terminal, ermittelt man die Prozessnummer, z.B. mit {{{#!vorlage Befehl ps -a }}} und setzt ein Signal `-USR1` ab. (bei Lucid Lynx mit ''sudo''). {{{#!vorlage Befehl kill -USR1 }}} Die bisher kopierte Datenmenge wird dann in dem Terminal angezeigt, in dem `dd` gestartet wurde. Mit einer Kombination aus `dd` und einer Schleife kann man dies auch automatisieren. {{{#!vorlage Befehl dd if=/dev/XXX of=/dev/XXX & ddpid=$! ; while [ $(ps -a | grep $ddpid) ]; do kill -SIGUSR1 $ddpid; sleep 10; done }}} ==== mit `pkill` ==== Sofern nur ein Prozess mit dem Namen `dd` läuft kann man dies auch über den Prozessnamen. {{{#!vorlage Befehl pkill -USR1 -x dd }}} In einer Schleife kann das so aussehen: {{{#!vorlage Befehl dd if=/dev/XXX of=/dev/XXX & while [ $(pkill -USR1 -x dd) ]; do sleep 10 ; : ; done }}} ==== mit `pv` ==== Als Alternative zur oben beschriebenen Vorgehensweise kann man auch den Befehl `pv` verwenden, um sich den Fortschritt anzeigen zu lassen (`pv` muss vorher aus den universe-Quellen installiert worden sein [2] [3]). Dabei wird `pv` mittels einer Pipe dazwischengeschaltet, als Beispiel wird hier [:Shell/dd#Festplatte-klonen: Festplatte klonen] angenommen. {{{#!vorlage Befehl dd if=/dev/sdx bs=1M | pv | dd of=/dev/sdy bs=1M }}} Um sich anzeigen zu lassen, wie weit der Vorgang fortgeschritten ist und wann er voraussichtlich beendet sein wird, muss man allerdings die Größe der Partition bzw. der Festplatte kennen. Im folgenden Beispiel wird eine Festplatte mit 60 GB unterstellt und in eine Image-Datei geschrieben: {{{#!vorlage Befehl dd if=/dev/sdx bs=1M | pv -s 60G | dd of=/pfad/zum/Ziel/backup.img bs=1M }}} Die Ausgabe kann dann so aussehen: {{{ 24.2GB 0:44:21 [4.45MB/s] [=============> ] 40% ETA 1:05:38 }}} ETA zeigt dabei die verbleibende Zeit an, bis die Operation (bei aktueller Geschwindigkeit) voraussichtlich fertig sein wird. == Live USB-Stick erstellen == Mit `dd` lässt sich auch auf einfachste Art und Weise ein Live USB-Stick (als Ersatz für eine Live-CD) erstellen. Zwingende Voraussetzung ist allerdings ein entsprechendes Hybrid ISO-Image. Die Live-ISO-Images von Ubuntu sind erst ab [:Oneiric:Ubuntu 11.10] Hybrid ISO-Images. Auch viele andere Linux-Distributionen stellen diese zur Verfügung. Erfolgreich getestet wurde z.B. [:Parted_Magic:] (ab Version 5.5). Im folgenden Beispiel wird davon ausgegangen, dass der USB-Stick als `/dev/sdc` erkannt wurde und nicht [:mount#Dateisysteme-aushaengen:eingebunden] ist (aber bitte nicht auswerfen bzw. ''"sicher entfernen"''): {{{#!vorlage Befehl sudo dd if=hybrid_iso_image.iso of=/dev/sdc bs=4M }}} Den Parameter `bs=4M` kann man auch weglassen, aber er beschleunigt den Kopiervorgang. Nach dem Befehl {{{#!vorlage Befehl sync }}} kann das Medium entfernt werden. Weitere Tipps zu bootbaren USB-Medien findet man im Artikel [:Live-USB:]. = Alternativen = Wer lieber mit einer Benutzeroberfläche arbeitet, kann zur Datensicherung auch [:partimage:] oder [:air-imager:] nutzen. = Links = * [http://compressionratings.com/i_gzip.html] {en} # tag: Shell, Datensicherung, Klonen, Image