Come usare il comando dd su Linux: guida pratica

dd non copia file: scrive blocchi grezzi

Il comando dd è uno di quelli che si usano quando serve lavorare a basso livello: immagini disco, backup raw, clonazione di partizioni, restore rapido, wipe mirato, creazione di supporti avviabili. Non è un tool “comodo”, è un tool preciso. Se lo usi bene, risparmi tempo. Se sbagli argomento, puoi sovrascrivere il disco sbagliato in pochi secondi.

La regola pratica è semplice: dd non ragiona in termini di file, ma di blocchi. Legge da un input grezzo e scrive su un output grezzo. Questo lo rende utile per i casi in cui il filesystem non basta più, o non vuoi fidarti del livello superiore. Lo rende anche pericoloso, perché non ti chiede conferme e non ha protezioni contro un target errato.

In questa guida vedi come usarlo in modo operativo su Linux, con esempi realistici, verifiche prima e dopo, e i punti in cui conviene fermarsi e controllare due volte.

Quando ha senso usare dd

Usa dd quando ti serve una copia bit-a-bit o quando il contenuto che vuoi trattare non è rappresentato bene come albero di file. I casi tipici sono questi:

• clonare un disco o una partizione verso un altro disco;
• creare un’immagine di backup di un supporto intero;
• ripristinare un’immagine raw su un nuovo device;
• scrivere un ISO su USB senza passare da tool grafici;
• cancellare velocemente metadati o riempire uno spazio con zeri;
• misurare velocità reale di scrittura o lettura in modo grezzo.

Se invece devi sincronizzare file, mantenere permessi e differenze incrementali, rsync è quasi sempre più adatto. dd è il martello: ottimo per certi chiodi, pessimo per tutto il resto.

La sintassi base che serve davvero

La forma più comune è questa:

dd if=/percorso/input of=/percorso/output bs=4M status=progress

Le opzioni che contano di più sono:

• if=: input file, cioè la sorgente;
• of=: output file, cioè la destinazione;
• bs=: dimensione del blocco, utile per performance;
• status=progress: mostra l’avanzamento;
• conv=fsync: forza la scrittura su disco a fine operazione;
• count=: numero di blocchi da leggere/scrivere;
• skip= e seek=: saltano blocchi in input o output.

Su Linux moderno, status=progress è comodo perché evita di aprire un secondo terminale per controllare se il comando è ancora vivo. Non è un requisito, ma in pratica riduce gli errori operativi.

Prima di toccare un disco: identifica bene i device

Il controllo più importante con dd non è il comando, è l’identificazione del device. Se confondi /dev/sda con /dev/sdb, il problema non è il tool: è l’operazione che hai scelto senza verificare.

Prima di scrivere, controlla sempre la mappa dei dischi con comandi che mostrano dimensioni, mount point e tipo di filesystem:

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,MODEL

Atteso: il disco giusto deve essere riconoscibile per dimensione e modello. Se il device non è montato, non basta vedere il nome: verifica anche il campo MOUNTPOINT. Se il target è un disco USB, stacca e riattacca il supporto e confronta l’output prima e dopo per isolare il device corretto.

Un secondo controllo utile è leggere i dettagli dal kernel:

dmesg | tail -n 50

Questo aiuta a capire quale device è stato appena inserito, soprattutto su server con molti dischi o su ambienti di recovery.

Creare un’immagine raw di un disco o di una partizione

Per salvare l’intero contenuto di un disco in un file immagine:

dd if=/dev/sdX of=/backup/disk.img bs=4M status=progress conv=fsync

Sostituisci /dev/sdX con il device corretto, non con una partizione se vuoi copiare tutto il disco. Il file risultante contiene tabella partizioni, filesystem, bootloader e ogni byte leggibile dalla sorgente.

Se invece vuoi copiare solo una partizione:

dd if=/dev/sdX1 of=/backup/partizione.img bs=4M status=progress conv=fsync

Qui il vantaggio è che puoi ripristinare la partizione senza dover ricostruire il contenitore disco. Lo svantaggio è che devi sapere esattamente cosa stai salvando e come verrà ripristinato più avanti.

Se vuoi comprimere al volo, puoi concatenare lo stream a gzip o zstd. In genere è una buona idea quando il disco contiene molto spazio libero, perché riduci tempo e spazio occupato dal backup:

dd if=/dev/sdX bs=4M status=progress | gzip > /backup/disk.img.gz

Nota pratica: la compressione è utile solo se il contenuto è comprimibile. Su dati già compressi, database binari o immagini, il guadagno può essere minimo.

Ripristinare un’immagine su un disco

Il restore è il punto in cui dd va trattato con disciplina. Il comando è simmetrico al backup, ma l’impatto è più alto perché sovrascrivi la destinazione.

dd if=/backup/disk.img of=/dev/sdX bs=4M status=progress conv=fsync

Prima di lanciare il comando, verifica tre cose: il device di destinazione è quello giusto, non è montato, e non contiene dati da preservare. Se il disco è in uso, smonta le partizioni e controlla che non esistano processi aperti sul mount point.

umount /dev/sdX1

Se il device è occupato, umount fallisce e devi vedere chi lo sta usando prima di procedere. Su server di produzione, il restore va trattato come change controllato con finestra e rollback, non come prova rapida.

Scrivere una ISO su USB

Uno degli usi più comuni è copiare una ISO bootabile su una chiavetta. Anche qui il target è il device intero, non la partizione. Se la chiavetta è /dev/sdb, non scrivere su /dev/sdb1.

dd if=linux.iso of=/dev/sdX bs=4M status=progress conv=fsync

Dopo la scrittura, il kernel può ancora avere in cache la vecchia tabella partizioni. In alcuni casi conviene scollegare e ricollegare il supporto, oppure chiedere al kernel di rileggere la tabella, ma solo se il device non è in uso.

Se la chiavetta viene usata spesso per recovery, etichettala fisicamente. È banale, ma aiuta a evitare errori quando hai più supporti identici collegati.

Velocità: blocco, cache e contesto fanno differenza

La performance di dd dipende soprattutto dalla dimensione del blocco e dal tipo di storage. Un bs troppo piccolo aumenta l’overhead di sistema; uno troppo grande non sempre porta vantaggi. In pratica, bs=4M è spesso un buon punto di partenza per dischi moderni e USB decenti.

Se vuoi fare un test rapido di throughput senza scrivere file permanenti, puoi misurare la velocità di scrittura verso /dev/null o leggere da /dev/zero. Questo non rappresenta un benchmark serio del disco, ma serve a capire se la pipeline base funziona:

dd if=/dev/zero of=/tmp/testfile bs=1G count=1 conv=fdatasync

Qui il parametro conv=fdatasync forza la sincronizzazione dei dati, così il tempo misurato è più vicino alla scrittura reale. Senza sincronizzazione, il risultato può essere falsato dalla cache del kernel.

Se vuoi leggere un file senza coinvolgere il disco in scrittura, puoi fare un test di lettura verso /dev/null:

dd if=/path/filegrande of=/dev/null bs=4M status=progress

Saltare, tagliare e copiare solo una parte

dd diventa molto utile quando devi lavorare su porzioni specifiche. Le opzioni skip, seek e count ti permettono di estrarre o scrivere solo una finestra di blocchi.

Per esempio, per leggere i primi 100 MiB di un disco:

dd if=/dev/sdX of=/backup/head.img bs=1M count=100 status=progress

Per saltare i primi 100 MiB in input e copiare il resto:

dd if=/dev/sdX of=/backup/resto.img bs=1M skip=100 status=progress

Queste operazioni sono utili in analisi forense, recovery o debugging di strutture disco, ma richiedono precisione sulla dimensione del blocco. Se cambi bs, cambiano anche le unità logiche di skip e count.

Azzerare spazio, non il mondo intero

Un uso classico è riempire un file o una partizione con zeri per liberare spazio comprimibile, preparare un’immagine o ripulire dati residui su un filesystem prima di una copia. Qui serve distinguere bene tra file, partizione e disco.

Per creare un file pieno di zeri di 1 GiB:

dd if=/dev/zero of=/tmp/zero.bin bs=1M count=1024

Se vuoi poi rimuoverlo, il file sparisce, ma il suo contenuto può restare nel layer sottostante finché non viene sovrascritto. Se l’obiettivo è ridurre lo spazio occupato in un’immagine VM o in un backup, spesso conviene azzerare lo spazio libero e poi comprimere l’immagine.

Per sicurezza operativa, evita di usare dd per “pulire” supporti su cui non hai un piano di rollback. In ambienti con requisiti di cancellazione sicura, la procedura va definita in base al tipo di storage e alle policy aziendali, non con un comando copiato al volo.

Verifiche dopo l’esecuzione

Con dd non basta che il comando finisca senza errori: devi verificare che il contenuto sia stato scritto davvero e sul device giusto. Le verifiche minime dipendono dal caso d’uso.

• per una ISO su USB, verifica che il supporto sia avviabile e che la tabella partizioni sia coerente;
• per un backup raw, confronta dimensioni e, se possibile, checksum del file immagine;
• per un restore, monta la partizione o avvia il sistema e controlla i servizi attesi;
• per un test di scrittura, confronta il tempo dichiarato da dd con metriche di sistema come I/O wait e saturazione del device.

Un controllo utile per immagini compresse è il checksum:

sha256sum /backup/disk.img.gz

Il checksum non ti dice se il contenuto è corretto rispetto alla sorgente, ma ti permette di verificare che il file non sia stato corrotto nel trasferimento o nello storage.

Errori tipici e come evitarli

Gli errori più comuni con dd non sono tecnici, sono operativi. Il primo è invertire input e output. Il secondo è confondere il disco con la partizione. Il terzo è lanciare il comando senza aver verificato che il target sia smontato e inattivo.

Un errore molto frequente è usare il path sbagliato in un ambiente con dispositivi simili. Per ridurre il rischio, fai sempre un confronto prima e dopo l’inserimento del supporto:

lsblk -o NAME,SIZE,MODEL,MOUNTPOINT

Se il device non è chiaro, fermati. Il costo di cinque minuti di verifica è quasi sempre inferiore al costo di un restore sbagliato.

Altro punto spesso sottovalutato: dd non mostra errori in modo “amichevole”. Se stai leggendo da un disco con settori danneggiati, potresti vedere messaggi di I/O error solo a metà operazione. In scenari del genere, prima di insistere con dd, valuta se serve una strategia di recupero diversa, perché continuare a leggere può peggiorare la situazione.

Un flusso operativo sensato per usarlo in produzione

Se devi usare dd in un contesto che tocca dati reali, il flusso sano è questo:

1. identifica con precisione sorgente e destinazione con lsblk e dmesg;
2. verifica che il target non sia montato e non sia in uso;
3. decidi se ti serve disco intero, partizione o porzione di blocchi;
4. scegli bs in base al tipo di storage e mantienilo costante;
5. lancia il comando con status=progress e, se serve, conv=fsync;
6. controlla l’esito con checksum, mount di prova o avvio del supporto;
7. documenta il risultato e conserva il rollback, se esiste.

Questo approccio è meno “rapido” di un comando buttato lì, ma è quello che evita incidenti. La velocità vera non è scrivere prima: è non dover rifare tutto da capo.

Quando non usare dd

Non usare dd quando il problema è a livello di file e puoi risolverlo con strumenti più adatti. Non usarlo per migrazioni incrementali, per copie selettive di directory, o quando ti serve preservare attributi e differenze tra file. Non usarlo per operazioni che richiedono logica applicativa.

In sintesi: dd è perfetto quando vuoi controllo grezzo sul flusso dei byte. Fuori da quel perimetro, è spesso la scelta sbagliata. Il suo valore sta proprio lì: poche astrazioni, comportamento prevedibile, ma nessuna rete di sicurezza. Se lo tratti come uno strumento chirurgico e non come un comando generico, diventa uno dei tool più utili di Linux.