Come posso creare rapidamente un file di grandi dimensioni su un sistema Linux ( Red Hat Linux )?

dd farà il lavoro, ma leggere /dev/zeroe scrivere sull'unità può richiedere molto tempo quando è necessario un file di dimensioni diverse di centinaia di GB per il test ... Se è necessario farlo ripetutamente, il tempo si sommerà davvero.

Non mi interessa il contenuto del file, voglio solo che venga creato rapidamente. Come si può fare?

L'uso di un file sparse non funzionerà per questo. Ho bisogno che il file sia assegnato allo spazio su disco.

dddalle altre risposte è una buona soluzione, ma è lento per questo scopo. In Linux (e altri sistemi POSIX), fallocateche utilizza lo spazio desiderato senza doverlo effettivamente scrivere, funziona con la maggior parte dei moderni file system basati su disco, molto velocemente:

Per esempio:

fallocate -l 10G gentoo_root.img

Questa è una domanda comune, specialmente nell'attuale ambiente di ambienti virtuali. Sfortunatamente, la risposta non è così semplice come si potrebbe presumere.

dd è la prima scelta ovvia, ma dd è essenzialmente una copia e questo ti costringe a scrivere ogni blocco di dati (quindi, inizializzando il contenuto del file) ... E quell'inizializzazione è ciò che richiede così tanto tempo di I / O. (Vuoi farla impiegare ancora più tempo? Usa / dev / random invece di / dev / zero ! Quindi userai CPU e tempo di I / O!) Alla fine però, dd è una scelta sbagliata (anche se essenzialmente il impostazione predefinita utilizzata dalla VM "crea" GUI). Per esempio:

dd if=/dev/zero of=./gentoo_root.img bs=4k iflag=fullblock,count_bytes count=10G

troncare è un'altra scelta - ed è probabilmente il più veloce ... Ma è perché crea un "file sparse". In sostanza, un file sparse è una sezione del disco che contiene molti degli stessi dati e il file system sottostante "imbroglia" non memorizzando realmente tutti i dati, ma semplicemente "fingendo" che sia tutto lì. Pertanto, quando si utilizza truncate per creare un'unità da 20 GB per la propria macchina virtuale, il file system non alloca effettivamente 20 GB, ma inganna e dice che ci sono 20 GB di zeri lì, anche se solo una traccia sul disco potrebbe effettivamente (davvero) essere in uso. Per esempio:

 truncate -s 10G gentoo_root.img

fallocate è l' ultima - e migliore - scelta per l'uso con allocazione del disco VM, perché è essenzialmente "riserve" (o "assegna" tutto lo spazio che stai cercando, ma non si preoccupa di nulla scrivere così,. quando usi fallocate per creare uno spazio su disco virtuale da 20 GB, ottieni davvero un file da 20 GB (non un "file sparse", e non ti preoccuperai di scrivere nulla su di esso - il che significa che praticamente tutto potrebbe essere dentro lì - un po 'come un nuovo disco!) Ad esempio:

fallocate -l 10G gentoo_root.img

Linux e tutti i filesystem

xfs_mkfile 10240m 10Gigfile

Linux e alcuni filesystem (ext4, xfs, btrfs e ocfs2)

fallocate -l 10G 10Gigfile

OS X, Solaris, SunOS e probabilmente altri UNIX

mkfile 10240m 10Gigfile

HP-UX

prealloc 10Gigfile 10737418240

Spiegazione

Prova mkfile <size>myfile in alternativa a dd. Con l' -nopzione si nota la dimensione, ma i blocchi del disco non vengono allocati fino a quando i dati non vengono scritti su di essi. Senza l' -nopzione, lo spazio è zero, il che significa scrivere sul disco, il che significa prendere tempo.

mkfile è derivato da SunOS e non è disponibile ovunque. La maggior parte dei sistemi Linux xfs_mkfilefunziona esattamente allo stesso modo, e non solo sui file system XFS nonostante il nome. È incluso in xfsprogs (per Debian / Ubuntu) o in pacchetti simili.

Anche la maggior parte dei sistemi Linux ha fallocate, che funziona solo su determinati file system (come btrfs, ext4, ocfs2 e xfs), ma è il più veloce, poiché alloca tutto lo spazio dei file (crea file non bucati) ma non inizializza alcun di esso.

truncate -s 10M output.file

creerà un file da 10 M istantaneamente (M sta per 1024 * 1024 byte, MB sta per 1000 * 1000 - lo stesso con K, KB, G, GB ...)

MODIFICARE: come molti hanno sottolineato, questo non alloca fisicamente il file sul tuo dispositivo. Con questo potresti effettivamente creare un file di grandi dimensioni arbitrario, indipendentemente dallo spazio disponibile sul dispositivo, in quanto crea un file "scarso".

Quindi, nel fare ciò, rimanderai l'allocazione fisica fino all'accesso al file. Se stai mappando questo file in memoria, potresti non avere le prestazioni previste.

Ma questo è ancora un comando utile da sapere

Dove cercare è la dimensione del file desiderato in byte - 1.

dd if=/dev/zero of=filename bs=1 count=1 seek=1048575

Esempi in cui seek è la dimensione del file desiderato in byte

#kilobytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200K

#megabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200M

#gigabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200G

#terabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200T

Dalla manpage dd:

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, GB = 1000 * 1000 * 1000, G = 1024 * 1024 * 1024 e così via per T, P, E, Z, Y.

Per creare un file da 1 GB:

dd if=/dev/zero of=filename bs=1G count=1

Non so molto su Linux, ma ecco il codice C che ho scritto per falsificare file enormi su DC Share molti anni fa.

#include < stdio.h >
#include < stdlib.h >

int main() {
    int i;
    FILE *fp;

    fp=fopen("bigfakefile.txt","w");

    for(i=0;i<(1024*1024);i++) {
        fseek(fp,(1024*1024),SEEK_CUR);
        fprintf(fp,"C");
    }
}

Puoi anche usare il comando "si". La sintassi è abbastanza semplice:

#yes >> myfile

Premi "Ctrl + C" per fermarlo, altrimenti consumerà tutto il tuo spazio disponibile.

Per pulire questo file eseguito:

#>myfile

pulirà questo file.

Non penso che diventerai molto più veloce di dd. Il collo di bottiglia è il disco; scrivere centinaia di GB di dati richiederà molto tempo, indipendentemente da come lo si fa.

Ma ecco una possibilità che potrebbe funzionare per la tua applicazione. Se non ti interessa il contenuto del file, che ne dici di creare un file "virtuale" il cui contenuto sia l'output dinamico di un programma? Invece di aprire () il file, usa popen () per aprire una pipe verso un programma esterno. Il programma esterno genera dati ogni volta che è necessario. Una volta che la pipe è aperta, si comporta come un normale file in quanto il programma che ha aperto la pipe può fseek (), rewind (), ecc. Dovrai usare pclose () invece di close () quando sei fatto con il tubo.

Se la tua applicazione ha bisogno che il file abbia una certa dimensione, spetterà al programma esterno tenere traccia di dove si trova il "file" e inviare un eof quando è stata raggiunta la "fine".

Un approccio: se è possibile garantire che le applicazioni non correlate non utilizzino i file in modo contrastante, è sufficiente creare un pool di file di dimensioni diverse in una directory specifica, quindi creare collegamenti ad essi quando necessario.

Ad esempio, disporre di un pool di file chiamato:

• / Home / bigfiles / 512M-A
• / Home / bigfiles / 512M-B
• / Home / bigfiles / 1024M-A
• / Home / bigfiles / 1024M-B

Quindi, se hai un'applicazione che richiede un file 1G chiamato / home / oracle / logfile, esegui un "ln /home/bigfiles/1024M-A /home/oracle/logfile ".

Se è su un filesystem separato, dovrai usare un link simbolico.

I file A / B / etc possono essere utilizzati per garantire che non vi siano conflitti di utilizzo tra applicazioni non correlate.

L'operazione di collegamento è più veloce che puoi ottenere.

Il mkfile GPL è solo un (ba) sh wrapper di script attorno a dd; Il mkfile di BSD memorizza un buffer con un valore diverso da zero e lo scrive ripetutamente. Non mi aspetterei che il primo superasse il dd. Quest'ultimo potrebbe superare leggermente dd if = / dev / zero poiché omette le letture, ma tutto ciò che fa significativamente meglio probabilmente sta semplicemente creando un file sparse.

In assenza di una chiamata di sistema che alloca effettivamente lo spazio per un file senza scrivere dati (e Linux e BSD mancano di questo, probabilmente anche Solaris) potresti ottenere un piccolo miglioramento delle prestazioni usando ftrunc (2) / truncate (1) per estendere il file alla dimensione desiderata, mmap il file in memoria, quindi scrivere dati diversi da zero nei primi byte di ogni blocco del disco (utilizzare fgetconf per trovare la dimensione del blocco del disco).

Spina senza vergogna: OTFFS fornisce un file system che fornisce file arbitrariamente grandi (beh, quasi. Exabyte è il limite attuale) di contenuto generato. È solo per Linux, semplice C e nei primi anni alfa.

Vedi https://github.com/s5k6/otffs .

Questo è il più veloce che potessi fare (che non è veloce) con i seguenti vincoli:

• L'obiettivo del file di grandi dimensioni è quello di riempire un disco, quindi non può essere comprimibile.
• Utilizzo del filesystem ext3. ( fallocatenon disponibile)

Questo è il senso di ciò ...

// include stdlib.h, stdio.h, and stdint.h
int32_t buf[256]; // Block size.
for (int i = 0; i < 256; ++i)
{
    buf[i] = rand(); // random to be non-compressible.
}
FILE* file = fopen("/file/on/your/system", "wb");
int blocksToWrite = 1024 * 1024; // 1 GB
for (int i = 0; i < blocksToWrite; ++i)
{
   fwrite(buf, sizeof(int32_t), 256, file);
}

Nel nostro caso questo è per un sistema Linux incorporato e funziona abbastanza bene, ma preferirebbe qualcosa di più veloce.

Cordiali saluti il ​​comando è dd if=/dev/urandom of=outputfile bs=1024 count = XXstato così lento da essere inutilizzabile.