Come posso creare un file con una dimensione specifica da una riga di comando?

Come posso creare un file (ad es. Usando il touchcomando o un altro modo simile), ma con una dimensione specifica (ad es. 14 MB)?

Il caso d'uso è testare FTP con file di varie dimensioni. Se siamo in grado di creare un file con una dimensione specifica, sarà utile verificare il trasferimento FTP ecc.

Utilizzare truncate:

truncate -s 14M filename

Da 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

Nota: truncatepotrebbe non essere disponibile sul tuo sistema, ad es. Su Mac OS X non è installato di default (ma puoi installarlo facilmente, usando ad esempio macports). In questi casi potrebbe essere necessario utilizzare ddo headinvece.

EDIT: Il modo più semplice è probabilmente la rispostatruncate di Ashutosh Vishwa Bandhu , ma come sottolineato da @ offby1 che crea file sparsi che potrebbero non essere quello che desideri. Le soluzioni seguenti creano file normali e completi.

I seguenti comandi creano un file da 14 MB chiamato foo:

1. fallocate(grazie a @Breakthrough che l'ha suggerito nei commenti e vota la risposta di Ahmed Masud di seguito che la menziona anche.)

   fallocate -l 14000000 foo
   

   Questo comando è particolarmente impressionante poiché è veloce quanto truncate(istantaneo) indipendentemente dalla dimensione del file desiderata (a differenza delle altre soluzioni che saranno lente per file di grandi dimensioni) e tuttavia crea file normali, non sparsi:

   $ 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. Crea un file pieno di dati casuali

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

                                                                             o

   head -c 14MB /dev/urandom > foo
   

3. Crea un file riempito con \0s:

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

                                                                             o

   head -c 14MB /dev/zero > foo
   

4. Crea un file riempito con i primi 14 MB di dati di un altro file:

   head -c 14MB bar.txt > foo
   

5. Crea un file riempito con gli ultimi 14 MB di dati di un altro file:

   tail -c 14MB bar.txt > foo
   

In tutti gli esempi precedenti, il file sarà, 14*1000*1000se lo desideri 14*1024*1024, sostituirlo MBcon M. Per esempio:

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

fallocate tratta solo in byte, quindi dovresti farlo (14 * 1024 * 1024 = 14680064)

fallocate -l 14680064 foo

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

AVVISO dd sovrascriverà in silenzio qualsiasi cosa tu abbia i diritti su cui scrivere, se lo specifichi volontariamente o per caso. Assicurati di capire dd, ad es. con la lettura dd --helpe non si rovinano le righe di comando dd oppure si può facilmente creare una perdita irreversibile di dati, anche totale .

Per iniziare, if=è il file di input ed of=è il file di output . Controlla sempre di averlo capito bene, prima di eseguire il comando. :)

Usa la magia dd;) pagina man

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

causa 14 MB * 1024 = 14336 KB o:

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

E otterrai il file output.dat 14mb, pieno di zero: D

Questo dovrebbe essere il modo più veloce per farlo:

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

Altrimenti basta scrivere un programma C o perl veloce e sporco che cerca la posizione esatta e scrive un singolo byte. Questo è MOLTO più veloce di scaricare effettivamente i dati sui blocchi.

Se vuoi evitare file sparsi, allora su Linux (e possibilmente altri sistemi) puoi usare fallocate -l <length>da util-linux.

Se questo non è disponibile e disponi di un sistema conforme a POSIX, puoi scrivere un programma rapido e sporco usando la chiamata in libreria posix_fallocate (). posix_fallocate garantisce l'allocazione dell'intervallo specificato in modo da non ottenere un disco pieno al successivo utilizzo dell'intervallo se restituisce correttamente

Mentre ddè il modo portatile per farlo, i comandi mkfilee xfs_mkfilesono scritti appositamente per questo scopo e sono più veloci:

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

Il problema è che nessuno dei due comandi è universalmente disponibile, quindi non sono adatti per scrivere script portatili. Tuttavia, se lo sto facendo in modo interattivo tramite la riga di comando, questi sono i comandi che utilizzo.

Per impostazione predefinita, creano file a riempimento zero e non file sparsi (o "bucati") . Entrambi prendono invece l' -nopzione per creare file sparsi.

C'è un'altra opzione con Perl:

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

Questo creerà un file da 1 KB. Sostituisci 1024 con qualsiasi numero che ti piace.