Compactação de fluxo on-the-fly que não transborda para recursos de hardware?

Tenho 200 GB de espaço livre em disco, 16 GB de RAM (dos quais ~ 1 GB é ocupado pelo desktop e pelo kernel) e 6 GB de swap.

Eu tenho um SSD externo de 240 GB, com 70 GB usados ¹ e o restante livre, do qual preciso fazer backup no meu disco.

Normalmente, eu faria dd if=/dev/sdb of=Desktop/disk.imgo disco primeiro e depois o compactaria, mas fazer a imagem primeiro não é uma opção, pois isso exigiria muito mais espaço em disco do que eu tenho, mesmo que a etapa de compactação resulte em espaço livre sendo compactado para que o arquivo final pode caber facilmente no meu disco.

ddgrava em STDOUT por padrão e gzippode ler de STDIN, portanto, em teoria, eu posso escrever dd if=/dev/sdb | gzip -9 -, mas gzipleva muito mais tempo para ler bytes do que ddproduzi-los.

De man pipe:

Os dados gravados na extremidade de gravação do pipe são armazenados em buffer pelo kernel até serem lidos na extremidade de leitura do pipe.

Visualizo um |como sendo um tubo real - um aplicativo inserindo dados e o outro retirando dados da fila do tubo o mais rápido possível.

E quando o programa no lado esquerdo grava mais dados mais rapidamente do que o outro lado do canal pode esperar processá-los? Isso causará extrema utilização de memória ou troca, ou o kernel tentará criar um FIFO no disco, preenchendo o disco? Ou apenas falhará SIGPIPE Broken pipese o buffer for muito grande?

Basicamente, isso se resume a duas perguntas:

1. Quais são as implicações e os resultados de colocar mais dados em um canal do que os lidos de cada vez?
2. Qual é a maneira confiável de compactar um fluxo de dados em disco sem colocar todo o fluxo de dados não compactado no disco?

_{Nota 1: Não posso simplesmente copiar exatamente os primeiros 70 GB usados ​​e espero obter um sistema ou sistema de arquivos em funcionamento, devido à fragmentação e outras coisas que exigirão que todo o conteúdo esteja intacto.}

Tecnicamente, você nem precisa de dd:

gzip < /dev/drive > drive.img.gz

Se você fizer uso dd, você deve sempre ir com maior do que blocksize padrão como dd bs=1Mou sofrer o inferno syscall ( dd's de bloco padrão é de 512 bytes, uma vez que read()s e write()s isso é 4096syscalls por MiB, muita sobrecarga).

gzip -9usa muito mais CPU com muito pouco para mostrar. Se gzipvocê está atrasando, diminua o nível de compactação ou use um método de compactação diferente (mais rápido).

Se você estiver fazendo backups baseados em arquivos em vez de ddimagens, poderá ter alguma lógica que decida se deseja compactar ou não (não há sentido em fazer isso para vários tipos de arquivos). dar( taralternativa`) é um exemplo que possui opções para isso.

Se o seu espaço livre for ZERO (porque é um SSD que retorna zero de forma confiável após TRIM e você executou fstrime eliminou caches), você também pode usar ddcom conv=sparsesinalizador para criar uma imagem esparsa, descompactável e montável em loop, que usa espaço em disco zero para as áreas zero . Requer que o arquivo de imagem seja apoiado por um sistema de arquivos que suporte arquivos esparsos.

Alternativamente, para alguns sistemas de arquivos, existem programas capazes de exibir apenas as áreas usadas.

ddlê e grava dados um bloco de cada vez e só possui um bloco pendente. tão

valgrind dd if=/dev/zero status=progress of=/dev/null bs=1M

mostra que ddusa aproximadamente 1 MB de memória. Você pode brincar com o tamanho do bloco e soltar valgrind, para ver o efeito na ddvelocidade do bloco .

Quando você entra gzip, ddsimplesmente diminui a velocidade para corresponder gzipà velocidade. Seu uso de memória não aumenta, nem faz com que o kernel armazene os buffers no disco (o kernel não sabe como fazer isso, exceto por troca). Um cano quebrado só acontece quando uma das extremidades do cano morre; veja signal(7)e write(2)para detalhes.

portanto

dd if=... iconv=fullblock bs=1M | gzip -9 > ...

é uma maneira segura de fazer o que você procura.

Ao canalizar, o processo de gravação acaba sendo bloqueado pelo kernel, se o processo de leitura não estiver em andamento. Você pode ver isso executando

strace dd if=/dev/zero bs=1M | (sleep 60; cat > /dev/null)

Você verá que ddlê 1 MB e, em seguida, emite um write()que fica lá, aguardando um minuto enquanto sleepé executado. É assim que os dois lados de um pipe se equilibram: o kernel bloqueia as gravações se o processo de gravação for muito rápido e as leituras se o processo de leitura for muito rápido.

Não há implicações negativas além do desempenho: o canal possui um buffer, que geralmente é de 64 K; depois disso, uma gravação no canal simplesmente bloqueia até gzipler mais alguns dados.

Respondendo à pergunta real de como funciona: "e se o programa no lado esquerdo gravar mais dados mais rapidamente do que o outro lado do canal pode esperar processá-los?"

Isso não acontece. Há um buffer de tamanho limitado bastante pequeno no tubo; veja Qual é o tamanho do buffer do pipe?

Quando o buffer do pipe estiver cheio, o programa de envio será bloqueado . Quando faz uma chamada de gravação, o kernel não retornará o controle ao programa até que os dados tenham sido gravados no buffer. Isso fornece ao CPU o programa de leitura para esvaziar o buffer.

Talvez você só precise dos arquivos e use tar. Você pode preencher com zeros os blocos que não contêm o que quiser, alguém já perguntou sobre isso. Limpar espaço não utilizado com zeros (ext3, ext4)

Então, há o pigzque geralmente é mais rápido que gzip.