Gute Blockgröße für das Klonen von Festplatten mit diskdump (dd)

Ich benutze dd in seiner einfachsten Form, um eine Festplatte zu klonen:

dd if=INPUT of=OUTPUT

Ich habe jedoch in der Manpage gelesen, dass dd einen blocksize-Parameter kennt. Gibt es einen optimalen Wert für den Parameter blocksize, der das Klonen beschleunigt?

64k scheint eine gute Wahl zu sein:

Results:

  no bs=        78s     144584+0 records
  bs=512        78s     144584+0 records
  bs=1k         38s     72292+0 records
  bs=2k         38s     36146+0 records
  bs=4k         38s     18073+0 records
  bs=5k         39s     14458+1 records
  bs=50k        38s     1445+1 records
  bs=500k       39s     144+1 records
  bs=512k       39s     144+1 records
  bs=1M         39s     72+1 records
  bs=5M         39s     14+1 records
  bs=10M        39s     7+1 records

(von hier genommen ).

dies stimmt mit meinen eigenen erkenntnissen über das lesen / schreiben von puffern überein, um ein io-heavy konverter-programm zu beschleunigen, das ich einmal bei @work gepimpt habe.

dd kopiert gerne mit der BS von was auch immer Sie wollen und kopiert einen Teilblock (am Ende).

Grundsätzlich scheint der Parameter block size (bs) die Menge an Speicher festzulegen, die zum Einlesen eines Klumpens von einer Festplatte verwendet wird, bevor versucht wird, diesen Klumpen auf die andere zu schreiben.

Wenn Sie über viel RAM verfügen, bedeutet die Vergrößerung der BS (die jedoch vollständig im RAM enthalten ist), dass das E / A-Subsystem so gut wie möglich ausgelastet ist, indem sehr große Lese- und Schreibvorgänge ausgeführt werden - unter Ausnutzung des RAM. Wenn Sie die BS klein machen, steigt der E / A-Overhead im Verhältnis zur Gesamtaktivität.

Natürlich gibt es dabei ein Gesetz, das die Renditen mindert. Meine grobe Annäherung ist, dass eine Blockgröße im Bereich von 128K bis 32M wahrscheinlich eine solche Leistung ergibt, dass der Overhead im Vergleich zur normalen E / A gering ist und eine Vergrößerung keinen großen Unterschied macht. Der Grund für die Untergrenze von 128 KB bis 32 MB liegt darin, dass dies von Ihrem Betriebssystem, Ihrer Hardware usw. abhängt.

Wenn ich es wäre, würde ich ein paar Experimente durchführen, um eine Kopie / einen Klon mit einer BS von 128K und erneut mit (sagen wir) 16M zu planen. Wenn man merklich schneller ist, benutze es. Wenn nicht, verwenden Sie die kleinere BS der beiden.

Für diejenigen, die hier über Google landen, auch wenn diese Diskussion ein bisschen alt ist ...

Denken Sie daran, dass dd aus einem bestimmten Grund dumm ist: Je einfacher es ist, desto weniger Fehler können auftreten.

Komplexe Partitionierungsschemata (in Betracht gezogen wird eine Dual-Boot-Festplatte, die zusätzlich LVM für ihr Linux-System verwendet) führen dazu, dass in Programmen wie Clonezilla Fehler aus dem Holz geholt werden. Schlecht nicht gemountete Dateisysteme können ntfsclone in die Luft jagen.

Ein beschädigtes Dateisystem, das Sektor für Sektor geklont wurde, ist nicht schlechter als das Original. Ein beschädigtes Dateisystem nach einer fehlgeschlagenen "intelligenten Kopie" ist möglicherweise WIRKLICH in Verfassung.

Verwenden Sie im Zweifelsfall dd und gehen Sie forensisch vor. Forensische Bildgebung erfordert Sektor-für-Sektor-Kopien (in der Tat kann es mehr Sektoren erfordern, als Sie mit dd schaffen können, aber das ist eine lange Geschichte). Es ist langsam und mühsam, aber es wird die Arbeit korrekt erledigen.

Machen Sie sich auch mit den Optionen "conv = noerror, sync" vertraut, damit Sie Laufwerke klonen können, die allmählich ausfallen - oder ISOs von zerkratzten ( Husten- ) CDs erstellen können - ohne dass es Monate dauert.

Wie andere gesagt haben, gibt es keine universell korrekte Blockgröße; Was für eine Situation oder ein Teil der Hardware optimal ist, kann für ein anderes schrecklich ineffizient sein. Abhängig vom Zustand der Festplatten kann es auch vorzuziehen sein, eine andere Blockgröße als die "optimale" zu verwenden.

Eine Sache, die auf moderner Hardware ziemlich zuverlässig ist, ist, dass die Standardblockgröße von 512 Bytes fast eine Größenordnung langsamer ist als eine optimalere Alternative. Im Zweifelsfall habe ich festgestellt, dass 64K ein ziemlich solider moderner Standard ist. Obwohl 64K normalerweise nicht DIE optimale Blockgröße ist, ist es meiner Erfahrung nach viel effizienter als die Standardgröße. 64K hat auch eine ziemlich solide Erfolgsgeschichte: Sie finden eine Nachricht aus der Eug-Lug-Mailingliste von ca. 2002, in der eine Blockgröße von 64K empfohlen wird: http://www.mail-archive.com/eug- [email protected]/msg12073.html

Um DIE optimale Ausgabeblockgröße zu bestimmen, habe ich das folgende Skript geschrieben, das das Schreiben einer 128-MB-Testdatei mit dd in einem Bereich von verschiedenen Blockgrößen testet, von standardmäßig 512 Byte bis maximal 64 MB. Seien Sie gewarnt, dieses Skript verwendet dd intern. Seien Sie also vorsichtig.

dd_obs_test.sh:

#!/bin/bash

# Since we're dealing with dd, abort if any errors occur
set -e

TEST_FILE=${1:-dd_obs_testfile}
TEST_FILE_EXISTS=0
if [ -e "$TEST_FILE" ]; then TEST_FILE_EXISTS=1; fi
TEST_FILE_SIZE=134217728

if [ $EUID -ne 0 ]; then
  echo "NOTE: Kernel cache will not be cleared between tests without sudo. This will likely cause inaccurate results." 1>&2
fi

# Header
PRINTF_FORMAT="%8s : %s\n"
printf "$PRINTF_FORMAT" 'block size' 'transfer rate'

# Block sizes of 512b 1K 2K 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M
for BLOCK_SIZE in 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864
do
  # Calculate number of segments required to copy
  COUNT=$(($TEST_FILE_SIZE / $BLOCK_SIZE))

  if [ $COUNT -le 0 ]; then
    echo "Block size of $BLOCK_SIZE estimated to require $COUNT blocks, aborting further tests."
    break
  fi

  # Clear kernel cache to ensure more accurate test
  [ $EUID -eq 0 ] && [ -e /proc/sys/vm/drop_caches ] && echo 3 > /proc/sys/vm/drop_caches

  # Create a test file with the specified block size
  DD_RESULT=$(dd if=/dev/zero of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT conv=fsync 2>&1 1>/dev/null)

  # Extract the transfer rate from dd's STDERR output
  TRANSFER_RATE=$(echo $DD_RESULT | \grep --only-matching -E '[0-9.]+ ([MGk]?B|bytes)/s(ec)?')

  # Clean up the test file if we created one
  if [ $TEST_FILE_EXISTS -ne 0 ]; then rm $TEST_FILE; fi

  # Output the result
  printf "$PRINTF_FORMAT" "$BLOCK_SIZE" "$TRANSFER_RATE"
done

Auf GitHub ansehen

Ich habe dieses Skript nur auf einem Debian (Ubuntu) -System und unter OSX Yosemite getestet, daher werden wahrscheinlich einige Anpassungen erforderlich sein, um an anderen Unix-Versionen zu arbeiten.

Standardmäßig erstellt der Befehl eine Testdatei mit dem Namen dd_obs_testfile im aktuellen Verzeichnis. Alternativ können Sie einen Pfad zu einer benutzerdefinierten Testdatei angeben, indem Sie einen Pfad nach dem Skriptnamen angeben:

$ ./dd_obs_test.sh /path/to/disk/test_file

Die Ausgabe des Skripts ist eine Liste der getesteten Blockgrößen und ihrer jeweiligen Übertragungsraten wie folgt:

$ ./dd_obs_test.sh
block size : transfer rate
       512 : 11.3 MB/s
      1024 : 22.1 MB/s
      2048 : 42.3 MB/s
      4096 : 75.2 MB/s
      8192 : 90.7 MB/s
     16384 : 101 MB/s
     32768 : 104 MB/s
     65536 : 108 MB/s
    131072 : 113 MB/s
    262144 : 112 MB/s
    524288 : 133 MB/s
   1048576 : 125 MB/s
   2097152 : 113 MB/s
   4194304 : 106 MB/s
   8388608 : 107 MB/s
  16777216 : 110 MB/s
  33554432 : 119 MB/s
  67108864 : 134 MB/s

(Hinweis: Die Einheit der Übertragungsraten variiert je nach Betriebssystem.)

Um die optimale Leseblockgröße zu testen, könnten Sie mehr oder weniger den gleichen Prozess verwenden, aber anstatt von / dev / zero zu lesen und auf die Festplatte zu schreiben, würden Sie von der Festplatte lesen und nach / dev / null schreiben. Ein Skript dafür könnte so aussehen:

dd_ibs_test.sh:

#!/bin/bash

# Since we're dealing with dd, abort if any errors occur
set -e

TEST_FILE=${1:-dd_ibs_testfile}
if [ -e "$TEST_FILE" ]; then TEST_FILE_EXISTS=$?; fi
TEST_FILE_SIZE=134217728

# Exit if file exists
if [ -e $TEST_FILE ]; then
  echo "Test file $TEST_FILE exists, aborting."
  exit 1
fi
TEST_FILE_EXISTS=1

if [ $EUID -ne 0 ]; then
  echo "NOTE: Kernel cache will not be cleared between tests without sudo. This will likely cause inaccurate results." 1>&2
fi

# Create test file
echo 'Generating test file...'
BLOCK_SIZE=65536
COUNT=$(($TEST_FILE_SIZE / $BLOCK_SIZE))
dd if=/dev/urandom of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT conv=fsync > /dev/null 2>&1

# Header
PRINTF_FORMAT="%8s : %s\n"
printf "$PRINTF_FORMAT" 'block size' 'transfer rate'

# Block sizes of 512b 1K 2K 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M
for BLOCK_SIZE in 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864
do
  # Clear kernel cache to ensure more accurate test
  [ $EUID -eq 0 ] && [ -e /proc/sys/vm/drop_caches ] && echo 3 > /proc/sys/vm/drop_caches

  # Read test file out to /dev/null with specified block size
  DD_RESULT=$(dd if=$TEST_FILE of=/dev/null bs=$BLOCK_SIZE 2>&1 1>/dev/null)

  # Extract transfer rate
  TRANSFER_RATE=$(echo $DD_RESULT | \grep --only-matching -E '[0-9.]+ ([MGk]?B|bytes)/s(ec)?')

  printf "$PRINTF_FORMAT" "$BLOCK_SIZE" "$TRANSFER_RATE"
done

# Clean up the test file if we created one
if [ $TEST_FILE_EXISTS -ne 0 ]; then rm $TEST_FILE; fi

Auf GitHub ansehen

Ein wichtiger Unterschied in diesem Fall ist, dass die Testdatei eine Datei ist, die vom Skript geschrieben wird. Richten Sie diesen Befehl nicht auf eine vorhandene Datei, da sonst die vorhandene Datei mit zufälligen Daten überschrieben wird!

Für meine spezielle Hardware stellte ich fest, dass 128 KB die optimalste Eingangsblockgröße auf einer Festplatte und 32 KB die optimalste auf einer SSD war.

Obwohl diese Antwort die meisten meiner Erkenntnisse abdeckt, bin ich so oft auf diese Situation gestoßen, dass ich einen Blog-Post darüber geschrieben habe: http://blog.tdg5.com/tuning-dd-block-size/ Weitere Einzelheiten finden Sie hier zu den tests die ich dort durchgeführt habe.

Dieser StackOverflow-Beitrag kann auch hilfreich sein: dd: Wie berechnet man die optimale Blockgröße?

Ja, aber ohne viele Tests werden Sie es nicht finden. Ich habe festgestellt, dass 32M ein guter Wert für die Verwendung ist.

Klonen des alten Startlaufwerks auf eine neue SSD auf einer externen SSD (SSD auf SSD)

• unter Linux Ubuntu 18.04.2 LTS 64bit
• HP XW4600 (8 GB RAM, Intel Core 2 Quad Q6700 bei 2,66 GHz und 4 c / 4 t ohne HT)

Verwenden von Datenträgern (Tool)> Formatieren> ATA Secure Erase (2 Minuten)

$ lsblk -l /dev/sd?
NAME MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda    8:0    0 119,2G  0 disk 
sda1   8:1    0 119,2G  0 part /
sdb    8:16   0   2,7T  0 disk 
sdc    8:32   0   2,7T  0 disk 
sdd    8:48   0  12,8T  0 disk 
sde    8:64   0   2,7T  0 disk
sdf    8:80   1 465,8G  0 disk 

$ sudo fdisk -l /dev/sda
Disk /dev/sda: 119,2 GiB, 128035676160 bytes, 250069680 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

$ sudo fdisk -l /dev/sdf
Disk /dev/sdf: 465,8 GiB, 500107862016 bytes, 976773168 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

• sda: Kingston SSD (alt; Festplatten melden eine durchschnittliche Rate von 263 MB / s mit Peaks nahe 270 MB / s - kein Schreibtest aufgrund der Systemfestplatte)
• sdf: Crucial MX500, 500 GB, CT500MX500SSD1 (Datenträgerberichte: durchschnittliche Rd / Wr-Rate 284/262 MB / s und Zugriffszeit 0,05 ms, mit Spitzenwerten bei etwa 290/270 MB / s)

Testläufe:

$ sudo dd if=/dev/sda of=/dev/sdf
250069680+0 records in
250069680+0 records out
128035676160 bytes (128 GB, 119 GiB) copied, 3391,72 s, 37,7 MB/s
#       --vvvvv--                            *********
$ sudo dd bs=1M if=/dev/sda of=/dev/sdf
122104+1 records in
122104+1 records out
128035676160 bytes (128 GB, 119 GiB) copied, 473,186 s, 271 MB/s
#                                            *********  ********

Zweiter Versuch nach dem sicheren Löschen mit dem gleichen Ergebnis:

128035676160 bytes (128 GB, 119 GiB) copied, 472,797 s, 271 MB/s