Início / unix / Perguntas / 563203
Accepted
ceving
Asked: 2020-01-22 05:03:49 +0800 CST

Qual é o valor máximo para o argumento bs de dd?

  • 772

Eu quero escrever um CGI, que deve ler um número especificado de bytes de STDIN. Minha ideia é fazer assim:

dd bs=$CONTENT_LENGTH count=1

Mas eu queria saber se o tamanho do bloco é limitado por qualquer outra coisa além da RAM.

$ dd bs=1000000000000
dd: memory exhausted by input buffer of size 1000000000000 bytes (931 GiB)

A página de manual do coreutils do GNU não especifica nenhum limite.

dd

3 respostas

  1. Best Answer

    As especificações POSIX paradd não especificam um máximo explicitamente, mas existem alguns limites:

    Em uma plataforma de 64 bits, size_ttem 64 bits de comprimento; além disso, não é assinado, portanto dd, falhará quando forem fornecidos valores maiores que 2 64 – 1:

    $ dd if=/dev/zero of=/dev/null bs=18446744073709551616
dd: invalid number: ‘18446744073709551616’

    No Linux em x86 de 64 bits, SSIZE_MAXé 0x7ffffffffffffffL (execute echo SSIZE_MAX | gcc -include limits.h -E -para verificar), e esse é o limite de entrada:

    $ dd if=/dev/zero of=/dev/null bs=9223372036854775808
dd: invalid number: ‘9223372036854775808’: Value too large for defined data type

$ dd if=/dev/zero of=/dev/null bs=9223372036854775807
dd: memory exhausted by input buffer of size 9223372036854775807 bytes (8.0 EiB)

    Depois de encontrar um valor que seja aceito, o próximo limite é a quantidade de memória que pode ser alocada, pois ddprecisa alocar um buffer antes de poder ler nele.

    Depois de encontrar um valor que pode ser alocado, você atingirá o readlimite (no Linux e outros sistemas com limites semelhantes), a menos que você use GNU dde especifiqueiflag=fullblock :

    $ dd if=/dev/zero of=ddtest bs=4294967296 count=1
0+1 records in
0+1 records out
2147479552 bytes (2.1 GB, 2.0 GiB) copied, 38.3037 s, 56.1 MB/s

    ( ddcopiado pouco menos de 2 31 bytes, ou seja , o limite do Linux mencionado acima, nem metade do que eu pedi).

    Conforme explicado no link de perguntas e respostas acima, você precisará fullblockcopiar de forma confiável todos os dados de entrada em qualquer caso, para qualquer valor bsmaior que 1.

    • 23

  2. Independentemente do seu valor máximo, aí você tem um problema maior; da especificação POSIX:

    O ddutilitário deve copiar o arquivo de entrada especificado para o arquivo de saída especificado com possíveis conversões usando tamanhos de bloco de entrada e saída específicos. Ele deve ler a entrada um bloco por vez, usando o tamanho do bloco de entrada especificado; ele deve então processar o bloco de dados realmente retornado, que pode ser menor que o tamanho do bloco solicitado.

    (enfase adicionada)

    Como escrevi no passado , ddé uma ferramenta extremamente estúpida: no seu caso, basicamente se resume a

    char *buf = malloc(bs);
for(int i = 0; i < count; ++i) {
    int len = read(STDIN_FILENO, buf, bs);
    if(len == 0) break;
    write(STDOUT_FILENO, buf, len);
}
free(buf);

    bsé apenas o argumento ddusado para realizar a read(2)syscall, mas read(2)é permitido realizar uma "short read", ou seja, retornar menos bytes do que o solicitado. De fato, é o que ele faz se tiver alguns bytes disponíveis agora, mesmo que não sejam tudo o que você pediu; isso é típico se o arquivo de entrada for um tty, um pipe ou um socket (então você está particularmente em risco com seu CGI...). Apenas tente:

    $ dd bs=1000 count=1
asd
asd
0+1 records in
0+1 records out
4 bytes copied, 1.75356 s, 0.0 kB/s

    Aqui eu digitei asde apertei enter; ddlê-lo (executando um single read(STDIN_FILENO, buf, 1000)e escrevê-lo; ele fez um readconforme solicitado, então ele sai. Não parece que ele copiou 1000 bytes.

    Em última análise, o "padrão" simples ddé uma ferramenta muito estúpida para a maioria das necessidades; você pode disputar para fazer o que você precisa:

    • usando bs=1e usando countpara o número de bytes; isso é garantido para copiar o número de bytes que você precisa (se disponível antes do EOF), mas é bastante ineficiente, pois executa uma syscall por byte;
    • adicione a fullblockbandeira; isso garante que ddacumule um bloco de entrada completo antes de escrevê-lo. Observe, no entanto, que isso não é padrão (GNU dd tem isso, IDK sobre outros).

    Por fim, se você estiver optando por uma extensão não POSIX, minha sugestão é apenas usar head -c: ele fará a coisa certa com buffer sensato e sem limites de tamanho específicos, garantindo correção e bom desempenho.

    • 6

  3. O máximo depende do sistema (incluindo suas políticas de alocação) e da memória disponível no momento.

    Em vez de tentar ler tudo de uma vez (você poderia esgotar a memória, desacelerar as coisas por causa da troca, você teria que adicionar verificações para ver se realmente funcionava ...), você poderia ler blocos de tamanho razoável com dd.

    Digamos que você queira ler esses bytes e colocá-los em um arquivo. No bash, você pode executar algo assim (o total de bytes está em $ total):

    block=65535
count=$(expr $total / $block)
rest=$(expr $total % $block)
(dd bs=$block count=$count;dd bs=$rest count=1) > filename
    • 2

relate perguntas