17 votos

¿Es mi comando clonar una unidad óptima?

He hecho la mitad de una hora de lectura en torno a preparar para clonar mi disco duro. Tiene varias particiones, incluyendo la partición de Windows. Me voy a comprar una gran unidad de disco duro externa para la copia de seguridad. Me gustaría ser capaz de utilizar este clon para restaurar la unidad de disco entera en caso de que algo va mal (que yo voy a hacer algunos OS re-arrastrando los pies). Quiero aprender a hacer esto usando dd, como me gusta el bajo nivel de herramientas que no requieren instalar nada.

He encontrado los siguientes útiles de código a partir de los foros de ubuntu (que entró desde una shell de root usando un live CD):

dd if=/dev/hda of=/dev/hdb & pid=$!
while kill -USR1 $pid; do sleep 1; done

(Sé que voy a tener que editar la entrada y salida de los lugares.) Sin embargo tengo dos preguntas. El primero es muy noobie: este comando está dividido en dos líneas. Seguramente cuando yo presione entrar después de que el signo de exclamación se iniciará el proceso?

Dos, en otros sitios se recomienda introducir el tamaño de bloque. Como este:

# dd if=/dev/hda conv=sync,noerror bs=64K of=/mnt/sda1/hda.img

No sé nada acerca de los tamaños de bloque. Es de 64 kb a la derecha? Se parece a mi el tamaño de bloque de 512 bytes a partir de la siguiente, la salida de sudo fdisk -ul:

Disk /dev/sda: 750.2 GB, 750156374016 bytes
255 heads, 63 sectors/track, 91201 cylinders, total 1465149168 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
Disk identifier: 0xc3ffc3ff

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *          63   143364059    71681998+   7  HPFS/NTFS/exFAT
Partition 1 does not start on physical sector boundary.
/dev/sda2       976867328  1465147391   244140032    7  HPFS/NTFS/exFAT
/dev/sda3       143364094   976867327   416751617    5  Extended
Partition 3 does not start on physical sector boundary.
/dev/sda5       143364096   162895871     9765888   82  Linux swap / Solaris
/dev/sda6       162897920   205864959    21483520   83  Linux
/dev/sda7       205867008   976867327   385500160   83  Linux

Partition table entries are not in disk order

Disk /dev/mapper/cryptswap1: 10.0 GB, 10000269312 bytes
255 heads, 63 sectors/track, 1215 cylinders, total 19531776 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
Disk identifier: 0x433bb3a7

Disk /dev/mapper/cryptswap1 doesn't contain a valid partition table

Gracias.

22voto

RN. Puntos 559

El progreso

El comando que aparece

dd if=/dev/hda of=/dev/hdb & pid=$!
while kill -USR1 $pid; do sleep 1; done

es un bonito dos-liner para conseguir el progreso de la dd sobre una base regular. Yo uso una muy similar. Se ve bien. Encontré aquí tal vez?

Blocksizes con dd: alineación y el rendimiento

Usted puede agregar un tamaño de bloque en el que se realicen las operaciones. No importa lo que el tamaño de bloque del dispositivo de bloque fundamental es conseguir que la operación de hecho igual de bien, pero por razones de rendimiento que usted puede elegir uno que se adapte a sus necesidades.

Primero de todo, es la alineación de la cosa. En caso de que su dispositivo de bloque funciona como 512KiB (como unidades flash hacer), sería muy lamentable para ejecutar dd con bs=512 (bytes), ya que esto provocará 1024 escribe (!) para cada bloque del dispositivo de perspectiva. En la práctica no va a ser tan malo como se escribe en el búfer y tomado en una sola vez, pero durante sincroniza todavía se puede amplificar la cantidad de escribe mucho.

A continuación, considere también la llanura de uso de CPU sobrecarga cuando se trata con una cantidad muy grande de pequeñas operaciones. Es más eficiente para tomar megabytes de una vez, cuando de copiar grandes cantidades de datos.

Mi mejor práctica es comenzar con 1MB como que es un buen múltiples de la mayoría de los set ups, incluyendo RAID tamaño de las bandas de LVM medida tamaños, etc. En mi portátil con SSD tiendo a ver una leve mejora el uso de 10 mb como tamaño de bloque, mientras que yo no la vea nunca más en mi disco duro físico.

El último bloque

No se preocupe acerca de la unidad/volumen de tamaño no ser un múltiplo del tamaño de bloque. El último bloque dd se copia será ajustado para que coincida con el último bit de datos. Puede ver si el último bloque tenía un tamaño diferente, buscando la salida.

18335302+0 records out

El +0 significa que fue una coincidencia exacta, +1 significa que no lo era. No es gran cosa.

Ver también

11voto

tdg5 Puntos 21

Como otros han dicho, no es universalmente correcto tamaño de bloque; ¿qué es la óptima para una situación o una pieza de hardware puede ser terriblemente ineficiente para otro. También, dependiendo de la salud de los discos puede ser preferible utilizar un tamaño de bloque distinto de lo que es "óptima".

Una cosa que es bastante fiable en hardware moderno es que por defecto el tamaño de bloque de 512 bytes tiende a ser casi un orden de magnitud más lento que una más óptima alternativa. Cuando en duda, he encontrado que es de 64 kb de un sólido bonito modernas predeterminado. A pesar de 64 KB por lo general no es EL óptimo tamaño de bloque, en mi experiencia tiende a ser mucho más eficiente que el valor predeterminado. 64 también tiene una bonita historia sólida de ser fiable rendimiento: Usted puede encontrar un mensaje de la Eug-Lug lista de correo, circa 2002, recomendando un tamaño de bloque de 64 KB.

Para determinar EL óptimo de salida tamaño de bloque, he escrito el siguiente secuencia de comandos que las pruebas de la escritura de un 128M archivo de prueba con dd en una gama de diferentes tamaños de bloque, desde el valor predeterminado de 512 bytes para un máximo de 64 M. Se advirtió, este script utiliza dd internamente, a fin de utilizar con precaución.

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}
[ -e "$TEST_FILE" ]; TEST_FILE_EXISTS=$?
TEST_FILE_SIZE=134217728

# 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

  # Create a test file with the specified block size
  DD_RESULT=$(dd if=/dev/zero of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT 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
  [ $TEST_FILE_EXISTS -ne 0 ] && rm $TEST_FILE

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

Ver en GitHub

Yo sólo he probado este script en Debian (Ubuntu) y en OSX Yosemite, por lo que probablemente tendrá algunos ajustes para hacer que el trabajo en otras variantes de Unix.

Por defecto, el comando crea un archivo de pruebas nombre dd_obs_testfile en el directorio actual. Alternativamente, usted puede proporcionar una ruta de acceso personalizado para un archivo de prueba mediante una vía después de que el nombre de secuencia de comandos:

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

La salida de la secuencia de comandos se muestra una lista de las pruebas de tamaños de bloque y su respectivo traslado las tasas de este modo:

$ ./dd_obs_test.sh
     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

(Nota: La unidad de la transferencia de las tarifas varían por el sistema operativo)

A prueba óptima de lectura de bloque de tamaño, usted podría utilizar más o menos el mismo proceso, pero en lugar de la lectura de /dev/zero y la escritura en el disco, que había leído de el disco y escribir /dev/null. Un script para hacer esto podría ser así:

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}
[ -e "$TEST_FILE" ]; TEST_FILE_EXISTS=$?
TEST_FILE_SIZE=134217728

# Exit if file exists
if [ -e $TEST_FILE ]; then
  echo "Test file $TEST_FILE exists, aborting."
  exit 1
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 > /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
  # 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
[ $TEST_FILE_EXISTS -ne 0 ] && rm $TEST_FILE

Ver en GitHub

Una diferencia importante en este caso es que el archivo de prueba es un archivo que está escrito el guión. No elija este comando en un archivo existente o el archivo existente se sobrescribe con datos aleatorios!

Para mi hardware en particular me pareció que 128K fue la más óptima de entrada tamaño de bloque en una unidad de disco duro y 32 k era el más óptimo en un SSD.

A pesar de esta respuesta, cubre la mayor parte de mis conclusiones, que he necesitado para determinar un óptimo dd tamaño de bloque suficiente de veces que escribí un post en el blog sobre ella. Usted puede encontrar más detalles sobre las pruebas que allí se llevan a cabo.

Este StackOverflow post también puede ser útil: dd: Cómo calcular el tamaño de bloque óptimo?

EnMiMaquinaFunciona.com

EnMiMaquinaFunciona es una comunidad de administradores de sistemas en la que puedes resolver tus problemas y dudas.
Puedes consultar las preguntas de otros sysadmin, hacer tus propias preguntas o resolver las de los demás.

Powered by:

X