Como posso criar um arquivo com um tamanho específico a partir de uma linha de comando?

Question

Como posso criar um arquivo (por exemplo, usando o comando touch ou outro modo semelhante), mas com um tamanho específico (por exemplo, 14 MB)?

O caso de uso é para testar o FTP com vários tamanhos de arquivo. Se pudermos criar um arquivo com um tamanho específico, será útil verificar a transferência de FTP, etc.

    

Answer 1

Use truncate :

truncate -s 14M filename

De man truncate :

DESCRIPTION
   Shrink or extend the size of each FILE to the specified size

[...]

 -s, --size=SIZE
          set or adjust the file size by SIZE

Observação: truncate pode não estar disponível em seu sistema, por exemplo no Mac OS X, ele não é instalado por padrão (mas você pode instalá-lo facilmente, usando macports, por exemplo). Nesses casos, talvez seja necessário usar dd ou head .

    

Answer 2

EDIT: A maneira mais simples é provavelmente a truncate da resposta do Ashutosh Vishwa Bandhu, mas como apontado por < um href="https://superuser.com/users/26991/offby1" @ offby1 que cria arquivos esparsos que pode não ser o que você deseja. As soluções abaixo criam arquivos normais e completos.

Os seguintes comandos criam um arquivo de 14MB chamado foo :

1. fallocate (graças a @Breakthrough que sugeriu nos comentários e votou Ahmed Masud's answer abaixo, que também menciona.)

   fallocate -l 14000000 foo
   

   Este comando é particularmente impressionante, pois é tão rápido quanto truncate (instantâneo), independentemente do tamanho de arquivo desejado (ao contrário das outras soluções que serão lentas para arquivos grandes) e ainda cria arquivos normais, não esparsos: / p>

   $ truncate -s 14MB foo1.txt 
   $ fallocate -l 14000000 foo2.txt 
   $ ls -ls foo?.txt 
       0 -rw-r--r-- 1 terdon terdon 14000000 Jun 21 03:54 foo1.txt
   13672 -rw-r--r-- 1 terdon terdon 14000000 Jun 21 03:55 foo2.txt
   

2. Crie um arquivo com dados aleatórios

   dd if=/dev/urandom of=foo bs=14MB count=1
   

   ou

   head -c 14MB /dev/urandom > foo
   

3. Crie um arquivo preenchido com 14*1000*1000 s:

   dd if=/dev/zero of=foo.txt bs=14MB count=1
   

   ou

   head -c 14MB /dev/zero > foo
   

4. Crie um arquivo com os primeiros 14 MB de dados de outro arquivo:

   head -c 14MB bar.txt > foo
   

5. Crie um arquivo com os últimos 14MB de dados de outro arquivo:

   tail -c 14MB bar.txt > foo
   

Em todos os exemplos acima, o arquivo será 14*1024*1024 se você quiser MB , substituir M por fallocate . Por exemplo:

dd if=/dev/urandom of=foo bs=14M count=1
head -c 14M /dev/zero > foo

%code% só lida em bytes, então você teria que fazer (14 * 1024 * 1024 = 14680064)

fallocate -l 14680064 foo

    

Answer 3

dd bs=1MB count=14 if=/dev/zero of=<yourfilename>

AVISO dd sobrescreverá qualquer coisa para o qual você tenha permissão para escrever, se você especificar de boa vontade ou por acidente. Certifique-se de entender dd , por exemplo. com a leitura de dd --help , e você não estraga as linhas de comando do dd ou então você pode facilmente criar uma perda de dados irreversível - mesmo total .

Para começar, if= é o arquivo de entrada e of= é o arquivo de saída . Sempre verifique se você acertou, antes de executar o comando. :)

    

Answer 4

Use magic dd ;) página man

$ dd if=/dev/zero of=output.dat  bs=1024  count=14336

causa 14MB * 1024 = 14336KB ou:

$ dd if=/dev/zero of=output.dat  bs=1MB  count=14

E você terá 14mb de arquivo output.dat, preenchido com zeros: D

    

Answer 5

Esta deve ser a maneira mais rápida de fazer isso:

SEEK=$SIZE-1
dd if=/dev/zero of=outfile bs=1 seek=$SEEK count=1 

Caso contrário, apenas escreva um programa C ou perl rápido e sujo que procure a posição exata e grave um único byte. Isso é muito mais rápido do que despejar dados nos blocos.

Se você quiser evitar arquivos esparsos, então no Linux (e possivelmente em outros sistemas) você pode usar fallocate -l <length> de util-linux .

Se isso não estiver disponível e você tiver um sistema compatível com POSIX, poderá escrever um programa rápido e sujo usando a chamada da biblioteca posix_fallocate (). posix_fallocate garante a alocação do intervalo especificado para que você não obtenha um disco cheio no uso subsequente do intervalo, se ele retornar com êxito

    

Answer 6

Enquanto dd é a maneira portátil de fazer isso, os comandos mkfile e xfs_mkfile são escritos especificamente para essa finalidade e são mais rápidos:

mkfile size[b|k|m|g] filename
xfs_mkfile size[b|k|m|g] filename

O problema é que nenhum comando está disponível universalmente, então eles não são bons para escrever scripts portáveis. No entanto, se eu estiver fazendo isso interativamente através da linha de comando, esses são os comandos que eu uso.

Por padrão, eles criam arquivos com preenchimento zero e não arquivos esparsos (ou "holey") . Ambos pegam a opção -n para criar arquivos esparsos.

    

Answer 7

Existe outra opção com o Perl:

perl -e 'print "a" x 1024' > file.txt

Isso criará um arquivo de 1 KB. Substitua 1024 por qualquer número que você goste.