Come creare un file con una determinata dimensione in Linux?

A scopo di test devo generare un file di una certa dimensione (per testare un limite di upload).

Qual è un comando per creare un file di una certa dimensione su Linux?

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

Dov'è file_sizela dimensione del file di test in byte

Per favore, il moderno è più facile e veloce. Su Linux, (scegline uno)

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

È necessario affermare che truncatesu un file system che supporta i file sparse creerà un file sparse e fallocatenon lo farà. Un file sparse è quello in cui le unità di allocazione che compongono il file non vengono effettivamente allocate fino a quando non vengono utilizzate. I metadati per il file occuperanno comunque uno spazio considerevole, ma probabilmente non si avvicinano alla dimensione effettiva del file. Si consiglia di consultare le risorse sui file sparsi per ulteriori informazioni in quanto vi sono vantaggi e svantaggi per questo tipo di file. Un file non sparse ha i suoi blocchi (unità di allocazione) allocati in anticipo, il che significa che lo spazio è riservato per quanto lo vede il file system. Inoltre, fallocatené truncateimposterà il contenuto del file su un valore specificato come dd, invece il contenuto di un file allocato con fallocateo truncatepuò essere qualsiasi valore di cestino che esisteva nelle unità allocate durante la creazione e questo comportamento può o non può essere desiderato. Il ddè il più lento perché in realtà scrive il valore o il blocco di dati per l'intero flusso di file come specificato con la sua linea di comando.

Questo comportamento potrebbe essere potenzialmente diverso - a seconda del file system utilizzato e della conformità di quel file system a qualsiasi standard o specifica. Pertanto si consiglia di effettuare ricerche adeguate per garantire che venga utilizzato il metodo appropriato.

Solo per seguire il post di Tom , puoi usare dd anche per creare file sparsi:

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

Ciò creerà un file con un "buco" al suo interno sulla maggior parte degli unix: i dati non verranno effettivamente scritti su disco o occuperanno spazio fino a quando non viene scritto qualcosa di diverso da zero.

Su OSX (e Solaris, a quanto pare), mkfileè disponibile anche il comando:

mkfile 10g big_file

Questo crea un file da 10 GB chiamato "big_file". Ho trovato questo approccio qui.

Usa questo comando:

dd if = $ INPUT-FILE di = $ OUTPUT-FILE bs = $ BLOCK-SIZE count = $ NUM-BLOCKS

Per creare un file grande (vuoto), impostare $INPUT-FILE=/dev/zero.
La dimensione totale del file sarà $BLOCK-SIZE * $NUM-BLOCKS.
Il nuovo file creato sarà $OUTPUT-FILE.

Puoi farlo a livello di codice:

#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;
}

Questo approccio è particolarmente utile per successivamente mmap il file in memoria.

utilizzare il comando seguente per verificare che il file abbia le dimensioni corrette:

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

Stai attento:

# du /tmp/foo.txt

probabilmente stamperà 0 perché è allocato come file Sparse se supportato dal tuo filesystem.

vedi anche: man 2 aperto e man 2 troncato

potresti fare:

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

Dove si sostituisce 100 con il numero di byte che si desidera scrivere.

Alcune di queste risposte ti utilizzano /dev/zeroper l'origine dei tuoi dati. Se la velocità di upload della rete di test potrebbe non essere la migliore idea se l'applicazione sta eseguendo una compressione, un file pieno di zeri viene compresso molto bene. Utilizzando questo comando per generare il file

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

Potrei comprimere upload_test fino a circa 200 byte. Quindi potresti metterti in una situazione in cui pensi che stai caricando un file da 10 KB, ma in realtà sarebbe molto meno.

Quello che suggerisco è usare /dev/urandominvece di /dev/zero. Non sono riuscito a comprimere affatto l'output /dev/urandom.

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

Ci sono molte risposte, ma nessuna ha spiegato bene cos'altro si può fare. Esaminando le pagine man per dd , è possibile specificare meglio le dimensioni di un file.

Questo creerà /tmp/zero_big_data_file.bin pieno di zeri, che ha una dimensione di 20 megabyte:

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

Questo creerà /tmp/zero_1000bytes_data_file.bin pieno di zeri, che ha una dimensione di 1000 byte:

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

o

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

• In tutti gli esempi, bs è la dimensione del blocco e count è il numero di blocchi
• BLOCCHI e BYTES possono essere seguiti dai seguenti suffissi moltiplicativi: 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 così via per T, P, E, Z, Y.

Come comando shell:

< /dev/zero head -c 1048576 >  output

Ciò genererà un file di testo di 4 MB con caratteri casuali nella directory corrente e il suo nome "4mb.txt" È possibile modificare i parametri per generare dimensioni e nomi diversi.

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

Uso fallocate se non si desidera attendere il disco.

Esempio:

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