Come si può usare `dd` per spostare i blocchi di dati a destra?

Considera un dispositivo a blocchi non elaborati da 100 MB come semplice esempio. Sono 204800 blocchi di 512 byte ciascuno per un totale di 102760448 byte.

La sfida è quella di spostare i primi 98 MB (200704 blocchi) in modo che vi sia uno spazio vuoto di 2 MB (4096 blocchi) davanti. Per fare questo sul posto è necessario che nulla sia scritto in un settore che non è stato letto. Un modo per raggiungere questo obiettivo è introdurre un buffer:

$ dd if=/dev/sdj2 count=200704 | mbuffer -s 512 -b 4096 -P 100 | dd of=/dev/sdj2 seek=4096

L'aspettativa è che mbuffermemorizzerà 4096 blocchi prima di passare qualsiasi cosa allo scrittore, assicurando così che nulla sia scritto in un'area che non è stata letta e che lo scrittore è in ritardo del lettore per le dimensioni del buffer. Il buffer dovrebbe consentire al lettore e allo scrittore di operare il più velocemente possibile all'interno di tali costrutti.

Tuttavia, non sembra funzionare in modo affidabile. Ho provato a utilizzare dispositivi reali ma non funziona mai su di essi, mentre gli esperimenti con un file hanno funzionato sulla mia casella a 64 bit ma non sulla mia casella a 32 bit.

Innanzitutto, alcuni preparativi:

$ dd if=/dev/sdj2 count=200704 | md5sum
0f0727f6644dac7a6ec60ea98ffc6da9
$ dd if=/dev/sdj2 count=200704 of=testfile

Questo non funziona:

$ dd if=/dev/sdj2 count=200704 | mbuffer -s 512 -b 4096 -P 100 -H | dd of=/dev/sdj2 seek=4096
summary: 98.0 MiByte in  4.4sec - average of 22.0 MiB/s
md5 hash: 3cbf1ca59a250d19573285458e320ade

Funziona su un sistema a 64 bit ma non su un sistema a 32 bit:

$ dd if=testfile count=200704 | mbuffer -s 512 -b 4096 -P 100 -H | dd of=testfile seek=4096 conv=notrunc
summary: 98.0 MiByte in  0.9sec - average of  111 MiB/s
md5 hash: 0f0727f6644dac7a6ec60ea98ffc6da9

Come può essere fatto in modo affidabile?

Appunti

Ho letto altre domande sul buffering e ho guardato pv, buffere mbuffer. Potevo solo far funzionare quest'ultimo con la dimensione del buffer richiesta.

L'uso della memoria intermedia è una soluzione ovvia al problema che funziona sempre, ma non è pratico quando non è disponibile una capacità di riserva sufficiente.

Piattaforme di prova che eseguono Arch Linux con la mbufferversione 20140302.

Senza un buffer, potresti andare indietro, un blocco alla volta.

for i in $(seq 100 -1 0)
do
    dd if=/dev/thing of=/dev/thing \
       bs=1M skip=$i seek=$(($i+2)) count=1
done

Si noti che questo esempio è pericoloso a causa della mancanza di controllo degli errori.

È anche lento a causa della quantità di ddchiamate. Se hai memoria da risparmiare, puoi usare un blocco di dimensioni maggiori.

Con un buffer, fai attenzione alle insidie . E ' non è sufficiente a garantire un pre-riempimento 100%. Ciò di cui hai bisogno è un riempimento minimo durante l'intero processo. Il buffer non deve mai scendere sotto 2Mperché altrimenti avrai sovrascritto nuovamente i tuoi dati ancora da leggere.

Quindi, mentre in teoria potresti fare a meno di qualsiasi tipo di buffer e solo catena dd:

dd if=/dev/thing bs=1M | \
dd bs=1M iflag=fullblock | \
dd bs=1M iflag=fullblock | \
dd of=/dev/thing bs=1M seek=2

In pratica questo non funziona in modo affidabile perché non vi è alcuna garanzia che il primo ddriesca a continuare a leggere i dati, mentre l'ultimo dd(con 2M"buffer" nel mezzo) sta già scrivendo.

È possibile aumentare considerevolmente le possibilità aumentando notevolmente il buffer tra, ma anche così, non è affidabile.

Purtroppo non conosco un buon programma di buffer con proprietà di riempimento minimo. È necessario uno che arresta l'output fintanto che nel buffer è presente un margine di sicurezza inferiore al margine di sicurezza.

Stai leggendo 4096 blocchi e quindi scrivendo quei 4096 blocchi nei successivi 4096 blocchi del disco, sovrascrivendo così i secondi 4096 blocchi prima che possano essere letti. Devi leggere 8129 blocchi per ottenere quei secondi 4096 prima di iniziare qualsiasi scrittura, e quindi devi solo scrivere 4096 blocchi prima di leggere il successivo 4096.

Non hai menzionato che tipo di filesystem sia. Se è ext [234] e hai una versione recente di e2fsprogs, puoi usare e2image -ra -O 512 /dev/sdj2. Questo ha anche il vantaggio di essere abbastanza intelligente da saltare lo spazio libero nel volume.

Una soluzione affidabile richiede di assicurarsi che nulla scriva in un'area che potrebbe non essere stata letta e l'unico modo reale per ottenere ciò è eseguire la copia in direzione inversa.

Lo ddrescuestrumento può funzionare in direzione opposta ma rifiuta di funzionare con input e output identici. Tuttavia è possibile ingannarlo duplicando il nodo del dispositivo.

Ho eseguito alcuni esperimenti rapidi e sembra funzionare. La riga di comando è:

$ ddrescue -f -R -s 200704s -o 4096s /dev/sdj11 /dev/sdj11_copy

Gli argomenti sono

• -f è richiesto per forzarlo a scrivere su un dispositivo di output esistente
• -R gli dice di funzionare in direzione opposta
• -sindica la quantità di input da copiare (ho usato il ssuffisso per specificare il numero di settori)
• -ogli dice di cercare in avanti nel dispositivo di output prima di scrivere (specificato di nuovo nei settori con il ssuffisso)
• /dev/sdj11 è il dispositivo a blocchi da leggere
• /dev/sdj11_copy è il dispositivo a blocchi da scrivere

Ho creato /dev/sdj11_copycon mknodper abbinare i parametri di /dev/sdj11.

Ho fatto solo alcuni test molto rapidi ma questo sembra funzionare bene per copiare un dispositivo non elaborato. Non funziona su un file (non potrei indurlo ad andare oltre i file essendo lo stesso)

Questo non risponde alla mia domanda originale che mi ha chiesto come raggiungere questo obiettivo, ddma penso che, avendo letto le altre risposte, la risposta è che ddnon è possibile farlo.