Como criar um arquivo com um determinado tamanho no Linux?

157

Para fins de teste, tenho que gerar um arquivo de um determinado tamanho (para testar um limite de upload).

O que é um comando para criar um arquivo de um determinado tamanho no Linux?

Grundlefleck
fonte

Respostas:

187
dd if=/dev/zero of=upload_test bs=file_size count=1

Onde file_sizeestá o tamanho do seu arquivo de teste em bytes

Ilya Kochetov
fonte
Ah, isso pode ser mais eficiente do que minha abordagem, porque faz tudo em um único bloco. Boa ideia.
Paul Tomblin 26/09/08
10
Na verdade, usar um tamanho de bloco enorme terá um desempenho muito pior quando ficar muito grande, pois alocará e lerá essa quantidade na memória antes de gravar. Se isso é algo como bs = 4GiB, você provavelmente acabará trocando.
Brian
35
ddtem um limite de 2 ^ 32 para os seus valores, de modo a criar um arquivo maior do que 4 GB, há um truque: dd if=/dev/zero of=test bs=1M count=<size in megabytes>.
Dmytro Sirenko 16/05
2
Ver próxima resposta para uma abordagem melhor, mais rápido
dice elegantes
2
@elegantdice não está claro qual é a resposta seguinte, eles podem mudar sua posição
vladkras
160

Por favor, moderno é mais fácil e mais rápido. No Linux, (escolha uma)

truncate -s 10G foo
fallocate -l 5G bar

É necessário declarar que truncateem um sistema de arquivos que suporta arquivos esparsos criará um arquivo esparso e fallocatenão. Um arquivo esparso é aquele em que as unidades de alocação que compõem o arquivo não são realmente alocadas até serem usadas. Os metadados para o arquivo , no entanto, ocupam um espaço considerável, mas provavelmente nem perto do tamanho real do arquivo. Você deve consultar recursos sobre arquivos esparsos para obter mais informações, pois há vantagens e desvantagens nesse tipo de arquivo. Um arquivo não esparso tem seus blocos (unidades de alocação) alocados antecipadamente, o que significa que o espaço é reservado na medida em que o sistema de arquivos o vê. Além disso fallocate, nem truncatenão irá definir o conteúdo do arquivo para um valor especificado como dd, em vez disso, o conteúdo de um arquivo alocado com fallocateou truncatepode ser qualquer valor do lixo que existia nas unidades alocadas durante a criação e esse comportamento pode ou não ser desejado. O ddé o mais lento porque, na verdade, ele grava o valor ou a parte dos dados em todo o fluxo de arquivos, conforme especificado nas opções da linha de comando.

Esse comportamento pode ser potencialmente diferente - dependendo do sistema de arquivos usado e da conformidade desse sistema de arquivos com qualquer padrão ou especificação. Portanto, é recomendável que a pesquisa apropriada seja feita para garantir que o método apropriado seja usado.

jørgensen
fonte
Eu tentei truncate. Produziu um arquivo de tamanho zero usando a sintaxe acima. A 'página de manual' de fallocatediz que os arquivos que ele cria estão cheios de spacedados em vez de vazios . Parece que não seria útil para alguns casos esperados, como "quanto tempo leva para copiar um arquivo 1G".
Mark Stosberg
6
fallocate parece funcionar bem para mim. Ele cria um arquivo do tamanho certo.
Aater Suleman
5
Esta é a melhor resposta para esta pergunta. O truncado / fallocate não demora muito, porque não grava todos os blocos do arquivo. Mas, se você carregasse o arquivo resultante em algum lugar, ele leria zeros para a coisa toda.
Mike Andrews
4
Se você deseja executar este sob OSX, então você vai precisar fazer isso: brew install coreutils. Isto irá adicionar um g na frente do comando, então você tem que executá-lo como este: gtruncate -s 10G foo. Espero que isto ajude!
DerekE
Parece que não funciona em uma NTFSpartição.
eloyesp
40

Apenas para acompanhar a publicação de Tom , você pode usar o dd para criar arquivos esparsos:

dd if=/dev/zero of=the_file bs=1 count=0 seek=12345

Isso criará um arquivo com um "buraco" na maioria dos unixes - os dados não serão gravados no disco ou ocuparão espaço até que algo diferente de zero seja gravado nele.

Brian
fonte
Definir contagem = 0 evita a necessidade de subtrair um byte do tamanho do arquivo.
andrewdotn
3
com count=0, bs * seektorna-se o tamanho do arquivo
Jayen
24

No OSX (e Solaris, aparentemente), o mkfilecomando também está disponível:

mkfile 10g big_file

Isso cria um arquivo de 10 GB chamado "big_file". Encontrei essa abordagem aqui.

Steve
fonte
Isso é útil para situações como o OS X, onde os comandos truncatee fallocatenão estão disponíveis. ddtambém funciona como descrito acima, embora seja mpara megabytes, não M.
user535673
Errado: Isso cria um arquivo de 10 GiB (= ~ 10,7 GB).
sobremesa
20

Use este comando:

dd se = $ INPUT-FILE de = $ OUTPUT-FILE bs = $ BLOCK-SIZE count = $ NUM-BLOCKS

Para criar um arquivo grande (vazio), defina $INPUT-FILE=/dev/zero.
O tamanho total do arquivo será $BLOCK-SIZE * $NUM-BLOCKS.
O novo arquivo criado será $OUTPUT-FILE.

Grundlefleck
fonte
Por que você fez a pergunta?
Henry B
9
Eu tive que procurar no Google a resposta, então coloquei aqui, para que pudesse ser discutido e atualizado ... você sabe, o objetivo de todo o site?
Grundlefleck 26/09/08
2
Eu sei que as pessoas estão votando no @Grundlefleck para a prostituição do XP, mas ele tem razão - uma das maneiras de usar este site, conforme previsto por Jeff e Joel, é fazer uma pergunta e responder por algo que você acabou de descobrir.
Paul Tomblin 26/09/08
3
Obrigado Paul. Embora eu não esteja tão preocupado com os pontos, estou preocupado com as coisas que encontro no Google que podem ser falhas de alguma maneira que eu nunca descobriria a menos que perguntasse aqui. As pessoas devem se sentir à vontade para tornar minha comunidade de perguntas e respostas propriedade se acharem que eu estou prostituindo, dando de ombros .
Grundlefleck 26/09/08
2
Para citar as perguntas frequentes "Também é perfeitamente bom perguntar e responder sua própria pergunta de programação, mas finja que você está no Jeopardy: coloque-o sob a forma de uma pergunta".
Craig Angus
17

Você pode fazer isso programaticamente:

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

int main() {
    int fd = creat("/tmp/foo.txt", 0644);
    ftruncate(fd, SIZE_IN_BYTES);
    close(fd);
    return 0;
}

Essa abordagem é especialmente útil para subsequentemente mapear o arquivo na memória.

use o seguinte comando para verificar se o arquivo tem o tamanho correto:

# du -B1 --apparent-size /tmp/foo.txt

Seja cuidadoso:

# du /tmp/foo.txt

provavelmente imprimirá 0 porque está alocado como arquivo esparso se suportado pelo seu sistema de arquivos.

veja também: man 2 open e man 2 truncate

Benedikt Waldvogel
fonte
10

você poderia fazer:

[dsm@localhost:~]$ perl -e 'print "\0" x 100' > filename.ext

Onde você substitui 100 pelo número de bytes que deseja gravar.

dsm
fonte
E o byte de preenchimento real também. Eu preciso de "\ xff" e funciona bem. Obrigado! :) #
Ray
10

Algumas dessas respostas você usa /dev/zeropara a fonte dos seus dados. Se o seu teste de upload de rede acelerar, essa pode não ser a melhor ideia se o seu aplicativo estiver fazendo uma compactação, um arquivo cheio de zeros será compactado muito bem. Usando este comando para gerar o arquivo

 dd if=/dev/zero of=upload_test bs=10000 count=1

Eu poderia comprimir upload_test até 200 bytes. Assim, você pode se colocar em uma situação em que acha que está enviando um arquivo de 10 KB, mas na verdade seria muito menor.

O que eu sugiro é usar em /dev/urandomvez de /dev/zero. Não consegui comprimir muito a saída /dev/urandom.

devin
fonte
Meu sistema incorporado não tem /dev/zero, então /dev/urandomé bom.
Fredrick Gauss
9
dd if=/dev/zero of=my_file.txt count=12345
Paul Tomblin
fonte
4
Lembre-se de que o tamanho padrão do bloco do dd é 512 bytes, portanto, este comando criará um arquivo 12345 * 512 bytes de tamanho.
ninguém
4

Existem muitas respostas, mas nenhuma explicou bem o que mais pode ser feito. Examinando as páginas de manual do dd , é possível especificar melhor o tamanho de um arquivo.

Isso criará o /tmp/zero_big_data_file.bin preenchido com zeros, com tamanho de 20 megabytes:

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

Isso criará /tmp/zero_1000bytes_data_file.bin preenchido com zeros, com tamanho de 1000 bytes:

    dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin  bs=1kB count=1

ou

    dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin  bs=1000 count=1

  • Em todos os exemplos, bs é o tamanho do bloco e count é o número de blocos
  • BLOCOS e BYTES podem ser seguidos pelos seguintes sufixos multiplicativos: c = 1, w = 2, b = 512, kB = 1000, K = 1024, MB = 1000 * 1000, M = 1024 * 1024, xM = M GB = 1000 * 1000 * 1000, G = 1024 * 1024 * 1024 e assim por diante para T, P, E, Z, Y.
BЈовић
fonte
3

Como comando shell:

< /dev/zero head -c 1048576 >  output
user1772090
fonte
3

Isso gerará um arquivo de texto de 4 MB com caracteres aleatórios no diretório atual e seu nome "4mb.txt". Você pode alterar os parâmetros para gerar tamanhos e nomes diferentes.

base64 /dev/urandom | head -c 4000000 > 4mb.txt
Berkay92
fonte
0

Usar fallocate se você não quiser esperar pelo disco.

Exemplo:

fallocate -l 100G BigFile

Uso:

Usage:
 fallocate [options] <filename>

Preallocate space to, or deallocate space from a file.

Options:
 -c, --collapse-range remove a range from the file
 -d, --dig-holes      detect zeroes and replace with holes
 -i, --insert-range   insert a hole at range, shifting existing data
 -l, --length <num>   length for range operations, in bytes
 -n, --keep-size      maintain the apparent size of the file
 -o, --offset <num>   offset for range operations, in bytes
 -p, --punch-hole     replace a range with a hole (implies -n)
 -z, --zero-range     zero and ensure allocation of a range
 -x, --posix          use posix_fallocate(3) instead of fallocate(2)
 -v, --verbose        verbose mode

 -h, --help           display this help
 -V, --version        display version
qin
fonte