Comment créer un fichier d'une taille spécifique à partir d'une ligne de commande?

Comment créer un fichier (par exemple, à l'aide de la touchcommande ou d'une autre manière similaire), mais avec une taille spécifique (par exemple 14 Mo)?

Le cas d'utilisation est de tester FTP avec différentes tailles de fichiers. Si nous pouvons créer un fichier avec une taille spécifique, il sera utile de vérifier le transfert FTP, etc.

Utiliser 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

Remarque: truncatepeut ne pas être disponible sur votre système, par exemple sur Mac OS X, il n'est pas installé par défaut (mais vous pouvez facilement l'installer, en utilisant macports par exemple). Dans ces cas, vous devrez peut-être utiliser ddou à la headplace.

EDIT: Le moyen le plus simple est probablement la réponsetruncate de Ashutosh Vishwa Bandhu , mais comme l'a souligné @ offby1, cela crée des fichiers fragmentés qui ne sont peut-être pas ce que vous voulez. Les solutions ci-dessous créent des fichiers normaux et complets.

Les commandes suivantes créent un fichier de 14 Mo appelé foo:

1. fallocate(merci à @Breakthrough qui l’a suggéré dans les commentaires et a voté contre la réponse d’ Ahmed Masud ci-dessous, qui le mentionne également.)

   fallocate -l 14000000 foo
   

   Cette commande est particulièrement impressionnante puisqu'elle est aussi rapide que truncate(instantanée) quelle que soit la taille du fichier souhaitée (contrairement aux autres solutions qui seront lentes pour les gros fichiers) et crée pourtant des fichiers normaux, pas des fichiers clairsemés:

   $ 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. Créer un fichier rempli de données aléatoires

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

                                                                             ou

   head -c 14MB /dev/urandom > foo
   

3. Créez un fichier rempli de \0s:

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

                                                                             ou

   head -c 14MB /dev/zero > foo
   

4. Créez un fichier contenant les 14 premiers Mo de données d’un autre fichier:

   head -c 14MB bar.txt > foo
   

5. Créez un fichier contenant les 14 derniers Mo de données d’un autre fichier:

   tail -c 14MB bar.txt > foo
   

Dans tous les exemples ci-dessus, le fichier sera 14*1000*1000si vous voulez 14*1024*1024, remplacez MBpar M. Par exemple:

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

fallocate traite uniquement en octets, il vous faudra donc le faire (14 * 1024 * 1024 = 14680064)

fallocate -l 14680064 foo

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

AVERTISSEMENT dd écrasera silencieusement tout ce que vous avez le droit d'écrire, si vous le spécifiez de plein gré ou par accident. Assurez-vous de comprendre dd, par exemple. en lecture dd --help, et vous ne bousillez pas vos lignes de commande dd ou vous pouvez facilement créer une perte de données irréversible - même totale .

Pour commencer, if=est le fichier d'entrée et of=le fichier de sortie . Vérifiez toujours que vous avez bien compris la situation avant d'exécuter la commande. :)

Utilisez la magie dd;) page de manuel

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

cause 14MB * 1024 = 14336KB, ou:

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

Et vous obtiendrez un fichier output.dat de 14mb, rempli de zéros: D

Cela devrait être le moyen le plus rapide de le faire:

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

Sinon, écrivez simplement un programme en C ou en Perl rapide et sale qui cherche la position exacte et écrit un seul octet. C'est BEAUCOUP plus rapide que de déposer des données sur les blocs.

Si vous voulez éviter les fichiers fragmentés, vous pouvez utiliser fallocate -l <length>depuis Linux (et éventuellement d’autres systèmes) util-linux.

Si ce n'est pas disponible et que vous avez un système compatible POSIX, vous pouvez écrire un programme rapide et sale en utilisant l'appel de la bibliothèque posix_fallocate (). posix_fallocate garantit l'allocation de la plage spécifiée, de sorte que vous n'obtiendrez pas de disque plein lors de l'utilisation ultérieure de la plage si cette dernière est renvoyée avec succès

Alors que ddc'est la façon portable de le faire, les commandes mkfileet xfs_mkfilesont écrites spécifiquement à cet effet et sont plus rapides:

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

Le problème est qu'aucune de ces commandes n'est universellement disponible. Elles ne sont donc pas adaptées à l'écriture de scripts portables. Cependant, si je le fais de manière interactive via la ligne de commande, ce sont les commandes que j'utilise.

Par défaut, ils créent des fichiers remplis à zéro et non des fichiers clairsemés (ou "troués") . Ils ont tous deux la -npossibilité de créer des fichiers fragmentés à la place.

Il y a une autre option avec Perl:

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

Cela créera un fichier de 1 Ko. Remplacez 1024 par le nombre de votre choix.