In this post I'm going to show you how to use the Unix dd utility to make disk images.

In questo post vi mostrerò come usare il programma Unix dd per creare immagini disco.

How to make disk images with the dd utility

Hello world, today I will show you how to make disk images by using dd.
Please notice that this won't be a full tutorial on the utility.

How to make a disk image containing an empty ext4 partition

You first need to make a file of a certain size with some content. You can do this by typing:

dd if=IP of=OP bs=BS count=C

Let's explain the parameters:

  • if=IP:
    This parameter stands for "input file", it tells dd where to get the data from, IP is a path to a file (the file can be of any type, block, character, etcetera).
  • of=OP:
    This parameter stands for "output file", it tells dd where to write the (read) data, OP has the same characteristics of IP with the difference that it is an output file.
  • bs=BS:
    This parameter stands for "bytes at a time", it tells dd how many bytes to read (from IP) and write (to OP) at a time.
  • count=C:
    This parameter tells dd how many blocks of input data (therefore from IP) have to be written in OP.

Please notice that the bs and count parameters might use the byte multipliers already seen in the split post.

Let's assume we want to make an empty partition of 1 Gb.
The command to use should be something similar to this:

dd if=/dev/zero of=file_containing_partition.img bs=1048576 count=1024

In the command above, the dd utility reads up to 1048576 bytes from the special file /dev/zero (as the name suggests, it always returns zeros), and stores them into the file "file_containing_partition.img".
This read/write operation happens exactly 1024 times.
If we make some calculations we understand why the result file will occupy 1 Gb of space.
In fact, we know that 1048576 bytes = 1024 ^ 2 bytes = 1 Mb, so, we're asking dd to store 1 Mb of data 1024 times, that is, a total of 1024 Mb = 1 Gb.
As already said, the bs and count parameters might use the byte multipliers (I say "might" because it seems that not all dd versions support this), the following command is equivalent:

dd if=/dev/zero of=file_containing_partition.img bs=1M count=1024
Now, let's use the mkfs command to format the partition:

mkfs -t T F

where T is the type of file system to apply and F is the path to the file.

In our case, we would format the partition in ext4:

mkfs -t ext4 file_containing_partition.img

Because the file is not a block device, the program will ask if you intend to continue this procedure, just answer affirmatively.

How to dump a cd

You first need to understand what is the block device of your disk drive (you can use the lsblk utility to do so).
In my case, that would be "/dev/sr0", so I would type something like:

dd if=/dev/sr0 of=cd_dump.iso

How to dump an existing partition

The procedure is the same as the one to dump a cd.
Let's say that "/dev/sdb1" is a partition we intend to dump, then we could use a command like this:

dd if=/dev/sdb1 of=partition_dump.img

I hope this post is useful to anyone, and as usual, see you another time, in another post!

Go back to the top, Share, Look at the comments or Comment yourself!

Come creare immagini disco con il programma dd

Salve mondo, oggi vi mostro come creare immagini disco usando dd.
Vi faccio notare che questo non sarà un tutorial completo su questo programma.

Come creare un immagine disco contenente una partizione ext4 vuota

Innanzitutto è necessario creare un file di una certa dimensione con un certo contenuto. Questo lo potete fare digitando:

dd if=IP of=OP bs=BS count=C

Spieghiamo i parametri:

  • if=IP:
    Questo parametro sta per "input file", dice a dd da dove prendere i dati, IP è un percorso ad un file (questo file può essere di qualsiasi tipo, a blocchi, a caratteri, eccetera).
  • of=OP:
    Questo parametro sta per "output file", dice a dd dove scrivere i dati (letti), OP ha le stesse caratteristiche di IP con la differenza che è un file di output.
  • bs=BS:
    Questo parametro sta per "byte alla volta", dice a dd quanti byte leggere (da IP) e scrivere (su OP) in una volta.
  • count=C:
    Questo parametro dice quanti blocchi di dati di input (quindi da IP) devono essere scritti su OP.

Vi faccio notare che le opzioni bs e count potrebbero utilizzare i moltiplicatori di byte già visti nel post su split.

Assumiamo di voler creare una partizione vuota da 1 Gb.
Il comando da usare dovrebbe essere qualcosa di simile a questo:

dd if=/dev/zero of=file_contenente_partizione.img bs=1048576 count=1024

Nel comando qui sopra, il programma dd legge fino a 1048576 byte dal file speciale /dev/zero (come suggerisce il nome, restituisce sempre degli zero), e li immagazzina nel file "file_contenente_partizione.img".
Quest'operazione di lettura/scrittura avviene esattamente 1024 volte.
Se facciamo un po' di calcoli, capiamo perché il file risultante occuperà 1 Gb di spazio.
Infatti, sappiamo che 1048576 byte = 1024 ^ 2 byte = 1 Mb, quindi, stiamo chiedendo a dd di immagazzinare 1 Mb 1024 volte, ovvero, un totale di 1024 Mb = 1 Gb.
Come già detto, i parametri bs e count potrebbero usare i moltiplicatori di byte (dico "potrebbero" perché sembra che non tutte le versioni di dd li supportino), il comando seguente è equivalente:

dd if=/dev/zero of=file_contenente_partizione.img bs=1M count=1024
Ora, usiamo il comando mkfs per formattare la partizione:

mkfs -t T F

dove T è il tipo di file system da applicare ed F è il percorso al file.

Nel nostro caso, formatteremmo la partizione in ext4:

mkfs -t ext4 file_contenente_partizione.img

Poiché il file non è un dispositivo a blocchi, il programma ci chiederà se intendiamo continuare con la procedura, rispondete affermativamente.

Come creare l'immagine disco di un cd

Bisogna innanzitutto capire qual'è il dispositivo a blocchi del vostro lettore dischi (potete usare il programma lsblk a tale scopo).
Nel mio caso, esso sarebbe "/dev/sr0", quindi digiterei una cosa del genere:

dd if=/dev/sr0 of=immagine_cd.iso

Come creare l'immagine disco di una partizione

La procedura è la stessa di quella per creare l'immagine di un cd.
Diciamo che "/dev/sdb1" è una partizione che intendiamo salvare, allora possiamo usare un comando tipo questo:

dd if=/dev/sdb1 of=immagine_partizione.img

Spero che questo post torni utile a qualcuno, e come al solito, ci si vede un'altra volta, in un altro post!

Torna in cima, Condividi, Guarda i commenti o Commenta tu stesso!