¿Cómo se puede volver a leer la image con dd para que coincida con la que acaba de escribir?

Tengo una image ~ 1GB que estoy escribiendo en una tarjeta SD de 8GB a través de la herramienta dd . Me gustaría verificar que fue escrito sin corrupción al leerlo y comparar su hash con el original.

Obviamente, cuando lo leo por dd el tamaño de la image resultante coincide con el tamaño de mi tarjeta SD, por lo tanto, verificar los hash es inútil.

Creo que de alguna manera debería interpretar el resultado de la invocación de escritura para configurar los parameters de skip / count para que vuelva a leerse correctamente.

Comando que solía escribir mi image:

 > sudo dd if=my.img of=/dev/sdc bs=1M 8+50581 records in 8+50581 records out 3947888640 bytes (3.9 GB) copied, 108.701 s, 36.3 MB/s 

Comando que solía leer mi image:

 > sudo dd if=/dev/sdc of=same_as_my.img 15523840+0 records in 15523840+0 records out 7948206080 bytes (7.9 GB) copied, 285.175 s, 27.9 MB/s 

Determine el tamaño de la image, por ejemplo con \ls -l my.img (no ls -lh , que le daría un tamaño aproximado; \ls protege contra un alias como ls='ls -h' ) o con stat -c %s my.img .

Si desea verificar la copy contra el original solo esta vez, simplemente compare los files. Usar hashes es inútil para una comparación de una sola vez, solo haría las cosas más lentas y requeriría más commands. El command cmp compara files binarys. Necesita pasar el file de image y la parte correspondiente de la tarjeta SD. Use la head para extraer el comienzo de la tarjeta SD.

 </dev/sdc head -c "$(stat -c %s my.img)" | cmp - my.img 

Si desea realizar muchas comparaciones, los hash son útiles, ya que solo necesita leer cada instancia una vez para calcular su hash. Cualquier hash servirá ya que estás preocupado por la corrupción de datos. Si necesita verificar que un file no se haya modificado por razones de security, entonces cksum y md5sum no serían adecuados, en su lugar debería usar sha256sum o sha512sum .

 md5sum <my.img >my.img.md5sum </dev/sdc head -c "$(stat -c %s my.img)" | md5sum >sd-copy.md5sum cmp my.img.md5sum sd-copy.md5sum 

Tenga en count la networkingirección de input en el primer command; esto garantiza que el file de sum de comprobación no contenga nombres de file, por lo que puede comparar los files de sum de comprobación. Si tiene un file de sum de comprobación y una copy para verificar, puede hacer el chequeo directamente con

 </dev/sdc head -c "$(stat -c %s my.img)" | md5sum -c my.img.md5sum 

Ah, y no use dd , es lento (o en el mejor de los casos no más rápido) y no detecta errores de copy.

Lo que hicimos fue md5um la partición real. No permite exactamente la sum de comprobación de la image con el disco, pero si tiene algunos discos (como nosotros), puede establecer la sum de verificación "adecuada".

Por ejemplo, en nuestro caso las particiones se ven así:

 $ sudo fdisk -l /dev/sdc Disk /dev/sdc: 7948 MB, 7948206080 bytes 245 heads, 62 sectors/track, 1021 cylinders, total 15523840 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 Device Boot Start End Blocks Id System /dev/sdc1 8192 122879 57344 c W95 FAT32 (LBA) /dev/sdc2 122880 7710719 3793920 83 Linux 

Entonces podemos simplemente generar un hash en la (s) partición (es) con:

 $ sudo md5sum /dev/sdc2 

Sin embargo, esto supone lo siguiente:

  • Tienes múltiples tarjetas SD con las que puedes probar
  • No monta la tarjeta SD antes de ejecutar el hash

Además, tenga en count que no puede realizar una sum de comprobación de todo el disco (es decir, '/ dev / sdc' en el ejemplo anterior), ya que dará un hash diferente basado en las properties de la tarjeta SD.

md5sum sería una buena solución aquí, para comparar el valor del file de image con el de la tarjeta SD.

¿Lo estás escribiendo en un sistema de files en la tarjeta SD? ¿O directamente? ¿Necesita contar si desea limitar la duración de la ejecución de los datos comparados?

dd debería decirle cuántos bytes se copyron.

Esto necesita ser capturado y utilizado con bs = x y count = y apropiados. Esto es para evitar acumular basura en una sugerencia de clúster.

EDITAR

captura la salida, esta es la línea que deseas, usa grep para bytes.

 254033920 bytes (254 MB) copied, 1.198 s, 212 MB/s 

entonces (excusa verbosity y backticks).

 # original dd dd if=/path/to/file of=/dev/sdc 2> tempfile # get bytes CNT=`cat tempfile | grep bytes | cut -d' ' -f1` # copy it back by byte dd bs=1 count=$CNT if=/dev/sdc of=/path/to/copy 

Esto será lento, entonces (y no voy a hacerlo aquí), necesita calcular el tamaño de bloque óptimo y el número de múltiplos integers para leer primero, y luego get el rest con un salto / búsqueda.

Pero un mejor enfoque sería leer un número networkingondeado de bloques y realizar el hash en una longitud truncada, el object no es leer todo el dispositivo si no es necesario.

 sudo sh -c ' dd bs=64k if="$1" of="$2" ! cmp -- "$1" "$2" 2>&1 | grep -qvF "EOF on $1" ' -- my.img /dev/sdc 

cmp comparará dos bytes de files para byte y retorno en function de si son idénticos o no. Si uno es más corto que el otro, pero ambos files son idénticos para toda la longitud del file más corto, entonces cmp devolverá 1 e informará EOF on <shorter file>... a stderr. Si ambos files son idénticos, cmp devolverá 0 y no informará nada en absoluto, pero si difieren de lo contrario, cmp devolverá 1 e informará en el byte donde difieren. Y entonces la statement anterior devolverá 1 para cualquier ejecución de cmp que produzca cualquier línea de salida en stdout o stderr que no coincida con EOF on $1 o 0 en caso contrario.

OMI, la mejor forma (la más fácil) de hacer esto es cuando usa dd, use un tamaño de byte (bs =) que pueda dividirse uniformemente en su file fuente. Esto resulta en un número integer de escrituras de bloque. Luego puede revertir el process (volver a leerlo) y asegurarnos de que leemos el número exacto de bytes, bs = y count = en el command de lectura, y lo canalizamos a través del progtwig de sum de comprobación.

Ejemplo:

ls

-rw-rw-r– 1 1006632960 myfile.iso

Genera una sum de comprobación:

sha256sum myfile.iso

8012fcba8bf71a7dd9e8179af40bce0fec57bb84b7426e4de807130ada63243d myfile.iso

El tamaño del file 1006632960 es divisible por 512. Entonces, usando dd:

sudo dd if = myfile bs = 512b de = / dev / sdi

resultados en esta salida:

3840 + 0 loggings en

3840 + 0 loggings fuera

El +0 es la parte importante aquí. Si ve algo que no sea +0, necesita un tamaño de bytes diferente en su command dd.

Luego, para verificar los resultados, use este command:

sudo dd if = / dev / sdi bs = 512b recuento = 3840 | sha256sum

y el resultado coincide con el sha256sum anterior, lo que significa que es una buena copy:

3840 + 0 loggings en

3840 + 0 loggings fuera

1006632960 bytes (1.0 GB, 960 MiB) copydos, 14.788 s, 68.1 MB / s

8012fcba8bf71a7dd9e8179af40bce0fec57bb84b7426e4de807130ada63243d –

La parte más difícil es get el tamaño de bytes correcto. Una vez que lo tienes, el rest es fácil.