Como criar um arquivo com um determinado tamanho no Linux?

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?

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

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

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.

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.

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.

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.

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

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.

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.

dd if=/dev/zero of=my_file.txt count=12345

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.

Como comando shell:

< /dev/zero head -c 1048576 >  output

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

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