Como sei se o dd ainda está funcionando?

Eu não usei ddmuito, mas até agora ainda não me falhou. No momento, eu trabalho ddhá mais de 12 horas - estou gravando uma imagem no disco de onde veio - e estou ficando um pouco preocupado, pois consegui dddo disco para a imagem em cerca de 7 horas.

Estou executando o OSX 10.6.6 em um MacBook com Core 2 Duo a 2,1ghz / core com 4GB de RAM. Estou lendo um arquivo .dmg em um disco rígido de 7200rpm (a unidade de inicialização) e estou gravando em uma unidade de 7200rpm conectada através de um conector SATA para USB. Deixei o tamanho do bloco como padrão e a imagem tem cerca de 160 gb.

EDIT: E, após 14 horas de puro estresse, ddfuncionou perfeitamente depois de tudo. Da próxima vez, porém, eu irei analisá-lo pve acompanhá-lo strace. Obrigado a todos por toda a sua ajuda.

Você pode enviar ddum determinado sinal usando o killcomando para fazer com que ele produza seu status atual. O sinal está INFOnos sistemas BSD (incluindo OSX) e USR1no Linux. No seu caso:

kill -INFO $PID

Você pode encontrar a identificação do processo ( $PIDacima) com o pscomando; ou consulte as alternativas pgrep e pkill no mac os x para obter métodos mais convenientes.

Mais simplesmente, como AntoineG aponta em sua resposta , você pode digitar ctrl-Tno shell executando dd para enviar o INFOsinal.

Como um exemplo no Linux, você pode fazer com que todos os ddprocessos ativos produzam status como este:

pkill -USR1 -x dd

Depois de emitir seu status, ddcontinuará enfrentando.

No OS X (não tente no Linux), você pode simplesmente digitar Ctrl+ Tno terminal em execução dd. Ele imprimirá a mesma saída que kill -INFO $PID, além do uso da CPU:

load: 1.40  cmd: dd 34536 uninterruptible 3.49u 64.58s
5020305+0 records in
5020304+0 records out
2570395648 bytes transferred in 4284.349974 secs (599950 bytes/sec)

Descobri lendo este tópico e tentando abrir uma nova guia no meu terminal, mas misturando ⌘+ Tcom Ctrl+ T.

Para dd, você pode enviar um sinal . Para outros comandos que estão lendo ou gravando em um arquivo, você pode observar a posição deles no arquivo lsof.

lsof -o -p1234    # where 1234 is the process ID of the command
lsof -o /path/to/file

Se você planeja com antecedência, canalize os dados pv.

Uma maneira mais geral é usar o iotopque exibe a quantidade atual de leitura / gravação em disco por programa.

EDIT: iotop -omostra apenas programas que realizam operações de E / S atualmente (agradecemos a Jason C por esse comentário).

Eu costumo me conectar stracea esse processo em execução (com a -p $PIDopção) para ver se ele permanece bloqueado em uma chamada do sistema ou se ainda está ativo.

Ou, se você estiver nervoso por enviar um sinal para o dd em execução, inicie outro dd para validar se isso funciona.

Para a próxima vez, você pode usar apenas pvdesde o início (se estiver disponível através do seu gerenciador de pacotes, instale-o). Este é um utilitário com o único objetivo de canalizar a entrada para a saída e monitorar o progresso e a velocidade.

Em seguida, para gravar uma imagem em uma unidade, digamos com tamanho de bloco de 4 MB:

pv -ptearb /path/to/image.bin | dd iflag=fullblock of=/dev/whatever bs=4M

Além do buffer inicial (compensado por uma sincronização final, que pode ser feita ddse você quiser), isso mostrará uma barra de progresso, velocidade média, velocidade atual e ETA.

A iflag=fullblockopção força o dd a pegar blocos completos de entrada pv, caso contrário, você estará à mercê do tubo para tamanhos de bloco.

Para ir para o outro lado, use dd para ler e pv para escrever, embora você precise especificar explicitamente o tamanho se a fonte for um dispositivo de bloco. Para um dispositivo de 4 GB:

dd if=/dev/whatever bs=4M | pv -ptearb -s 4096m > /path/to/image.bin

Você também pode determinar o tamanho automaticamente, algo como:

dd if=/dev/whatever bs=4M | pv -ptearb -s `blockdev --getsize64 /dev/whatever` > /path/to/image.bin

Realmente não importa que ordem você faz dde pvem, é inteiramente relacionados com o desempenho - se o dispositivo que você está lendo de ou para tem um ótimo desempenho para determinados tamanhos de blocos que deseja usar ddem vez de pvacessar esse dispositivo. Você pode até colocar um dddos dois lados, se quiser, ou não, se não se importar:

pv -ptearb /path/to/image.bin > /dev/whatever
sync

A partir da coreutilsv8.24, ddpossui suporte nativo para mostrar progresso. Basta adicionar a opção status=progress.

Exemplo:

dd if=arch.iso of=/dev/sdb bs=4M status=progress

Fonte

ddrescue lhe fornecerá estatísticas enquanto estiver em execução.

demo: http://www.youtube.com/watch?v=vqq9A01geeA#t=144s

Às vezes, você pode não conseguir usar o sinal INFO ou USR1 porque o fluxo stderr do ddprocesso não está acessível (por exemplo, porque o terminal no qual foi executado já estava fechado). Nesse caso, uma solução alternativa é fazer o seguinte (testado no FreeBSD, pode ser um pouco diferente no Linux):

1. Use iostatpara estimar a taxa média de gravação (MB / s) no dispositivo de destino, por exemplo:

   iostat -d -w30 ada0

   Substitua o nome do dispositivo de destino por ada0aqui e aguarde alguns minutos para que ele dê alguns resultados. O parâmetro "w" determina quantos segundos entre as amostras. Aumentá-lo fornecerá uma estimativa média melhor com menos variação, mas você terá que esperar mais.

2. Use pspara determinar há quanto tempo ddestá em execução:

   ps -xo etime,command | grep dd

   Converta isso em segundos para obter o total de segundos de tempo de execução.

3. Multiplique o total de segundos de tempo de execução pela taxa média de gravação para obter o total de MB transferidos.

4. Obtenha o tamanho do dispositivo em MB com:

   grep ada0 /var/run/dmesg.boot

   Substitua o nome do seu dispositivo de destino ada0. Divida o resultado pela taxa média de gravação para obter o tempo total de transferência em segundos. Subtraia o tempo que está sendo executado até agora para obter o tempo restante.

Essa estratégia só funciona se ddestiver gravando continuamente na taxa de gravação média atual desde o início. Se outros processos estiverem competindo pelos recursos da CPU ou de E / S (incluindo o barramento de E / S), isso poderá reduzir a taxa de transferência.

Comecei a usar o dcfldd (1), que mostra as operações do dd de uma maneira melhor.

Enquanto ddestiver em execução, eu executo isso em outro terminal como root:

while pgrep ^dd; do pkill -INFO dd; sleep 1; done

Ele imprime o ddstatus a cada 1 segundo na janela original do terminal em que ddestá sendo executado e fecha quando o comando é executado.

Você pode usar o progressque, em particular, mostra o progresso de uma corrida dd. Ele usa /proc/$pid/fde /proc/$pid/fdinfo que você também pode monitorar manualmente.

A wcharlinha (caracteres escritos) em /proc/$pid/iopode fornecer informações precisas sobre o ddprocesso. Desde que mude, o seu ddainda está funcionando!

Aqui está um pequeno script php, que você pode salvar e executar php filename.phpdurante o ddpara exibir os bytes gravados. O benefício agradável de assistir /proc/$pid/iomais kill -USR1 $(pidof dd)é que você não tem que alternar entre os terminais, o que nem sempre é uma opção.

<?php

/** Time between refreshs in seconds */
$refresh = 1;


/**
 * Start of Script 
 */

if (!($pid = exec('pidof dd')))
    exit("no dd running\n");

$history = array();
$break_ms = $refresh * 1000000;
$start_time = exec("ls -ld /proc/$pid --time-style=+\"%s\" | egrep -o [0-9]{10}");


fprintf(STDOUT, "PID: %s\n", $pid);
fprintf(STDOUT, "START TIME: %s\n\n", date("Y-m-d H:i:s", $start_time));


while (true) {
    if (isset($curr))
        array_push($history, $curr);

    if (count($history) > 10) array_shift($history);
    $oldest = reset($history);
    $latest = end($history);

    /**
     * get number of written bytes from /proc/$pid/io
     */
    #if (!($curr = exec("cat /proc/$pid/io | grep ^write_bytes | sed 's/write_bytes: //g'")))
    #    break;

    /* prepare proc_open() parameter */
    $descriptorspec = array(
        0 => array('pipe', 'r'), // stdin
        1 => array('pipe', 'w'), // stdout
        2 => array('pipe', 'w'), // stderr
    );

    $process = proc_open("cat /proc/$pid/io | grep ^write_bytes | sed 's/write_bytes: //g'", $descriptorspec, $pipes);
    if (!is_resource($process)) break;

    $stdout = stream_get_contents($pipes[1]);
    $stderr = stream_get_contents($pipes[2]);
    proc_close($process);

    if (!empty($stderr)) break;
    $curr = trim($stdout);

    /**
     * caculate elapsed time from start */
    $time_elapsed = time() - $start_time;

    /**
     * avg speed since start */
    $avg = $time_elapsed > 0 ? round($curr / $time_elapsed) : 0;

    /**
     * avg speed of last 10 updates */
    if (count($history) > 0)
        $speed = human_file_size(round(($latest - $oldest) / count($history) / $refresh));

    $output = sprintf("\rBYTES WRITTEN: %s [%s]  ::  CURRENT: %s/s  ::  AVERAGE: %s/s  ::  ELAPSED: %s", $curr, human_file_size($curr), isset($speed) ? $speed : 0, human_file_size($avg), gmdate("H:i:s", $time_elapsed));
    printf("%s%s", $output, str_repeat(" ", exec("tput cols") - strlen($output)));

    usleep($break_ms);
}

fprintf(STDOUT, "\ndd has finished!\n\n");

function human_file_size($size,$unit="") {
  if( (!$unit && $size >= 1<<30) || $unit == "GB")
    return number_format($size/(1<<30),2)." GB";
  if( (!$unit && $size >= 1<<20) || $unit == "MB")
    return number_format($size/(1<<20),2)." MB";
  if( (!$unit && $size >= 1<<10) || $unit == "kB")
    return number_format($size/(1<<10),2)." kB";
  return number_format($size)." bytes";
}