Comment créer un fichier d'une taille donnée sous Linux?

157

À des fins de test, je dois générer un fichier d'une certaine taille (pour tester une limite de téléchargement).

Qu'est-ce qu'une commande pour créer un fichier d'une certaine taille sous Linux?

Grundlefleck
la source
grande taille stackoverflow.com/questions/257844/…
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

Réponses:

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

file_sizeest la taille de votre fichier de test en octets

Ilya Kochetov
la source
Oh, cela pourrait être plus efficace que mon approche car elle fait tout en un seul bloc. Bonne idée.
Paul Tomblin le
10
En fait, l'utilisation d'une énorme taille de bloc fonctionnera bien pire une fois qu'elle devient très grande, car elle allouera et lira cette quantité en mémoire avant d'écrire. Si c'est quelque chose comme bs = 4 Go, vous finirez probablement par échanger.
Brian le
35
dda une limite de 2 ^ 32 pour ses valeurs, pour ainsi créer un fichier de plus de 4 Go, il y a un truc: dd if=/dev/zero of=test bs=1M count=<size in megabytes>.
Dmytro Sirenko
2
Voir la réponse suivante pour une approche meilleure et plus rapide
dés élégants
2
@elegantdice on ne sait pas quelle est la prochaine réponse, ils peuvent changer de position
vladkras
160

S'il vous plaît, le moderne est plus facile et plus rapide. Sous Linux, (choisissez-en un)

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

Il faut préciser que truncatesur un système de fichiers prenant en charge les fichiers épars, cela créera un fichier fragmenté et fallocatenon. Un fichier fragmenté est un fichier dans lequel les unités d'allocation qui composent le fichier ne sont pas réellement allouées tant qu'elles ne sont pas utilisées. Les méta-données du fichier prendront cependant un espace considérable, mais probablement loin de la taille réelle du fichier. Vous devriez consulter les ressources sur les fichiers épars pour plus d'informations, car ce type de fichier présente des avantages et des inconvénients. Un fichier non fragmenté a ses blocs (unités d'allocation) alloués à l'avance, ce qui signifie que l'espace est réservé pour autant que le système de fichiers le voit. De fallocateplus truncate, ne définira pas le contenu du fichier sur une valeur spécifiée comme dd, au lieu de cela, le contenu d'un fichier alloué avec fallocateou truncatepeut être toute valeur de corbeille qui existait dans les unités allouées lors de la création et ce comportement peut ou non être souhaité. Le ddest le plus lent car il écrit en fait la valeur ou le morceau de données dans le flux de fichiers entier comme spécifié avec ses options de ligne de commande.

Ce comportement peut être potentiellement différent - en fonction du système de fichiers utilisé et de la conformité de ce système de fichiers à toute norme ou spécification. Par conséquent, il est conseillé de faire des recherches appropriées pour s'assurer que la méthode appropriée est utilisée.

jørgensen
la source
J'ai essayé truncate. Il a produit un fichier de taille zéro en utilisant la syntaxe ci-dessus. La 'page de manuel' de fallocateindique que les fichiers qu'elle crée sont pleins de vides spaceplutôt que de données. Il semble que cela ne serait pas utile pour certains cas attendus comme "combien de temps faut-il pour copier un fichier 1G".
Mark Stosberg
6
fallocate semble bien fonctionner pour moi. Il crée un fichier de la bonne taille.
Aater Suleman
5
C'est la meilleure réponse à cette question. Le truncate / fallocate ne prend pas longtemps, car il n'écrit pas tous les blocs du fichier. Mais, si vous deviez ensuite télécharger le fichier résultant quelque part, il lirait des zéros pour l'ensemble.
Mike Andrews
4
Si vous voulez exécuter ce sous Mac OS X, alors vous aurez besoin de faire ceci: brew install coreutils. Cela ajoutera un g devant la commande, donc vous devez l' exécuter comme ceci: gtruncate -s 10G foo. J'espère que cela t'aides!
DerekE
Il semble que cela ne fonctionne pas sur une NTFSpartition.
eloyesp
40

Juste pour suivre la publication de Tom , vous pouvez également utiliser dd pour créer des fichiers épars:

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

Cela créera un fichier avec un "trou" dans la plupart des Unix - les données ne seront pas réellement écrites sur le disque, ou n'occuperont pas d'espace jusqu'à ce que quelque chose d'autre que zéro y soit écrit.

Brian
la source
La définition de count = 0 évite d'avoir à soustraire un octet de la taille du fichier.
andrewdotn
3
avec count=0, bs * seekdevient la taille du fichier
Jayen
24

Sur OSX (et Solaris, apparemment), la mkfilecommande est également disponible:

mkfile 10g big_file

Cela fait un fichier de 10 Go nommé "big_file". J'ai trouvé cette approche ici.

Steve
la source
Ceci est utile dans des situations telles que OS X où les commandes truncateet fallocatene sont pas disponibles. ddfonctionne également comme décrit ci-dessus bien que ce soit mpour des mégaoctets, non M.
user535673
Erreur: cela crée un fichier de 10 Gio (= ~ 10,7 Go).
dessert
20

Utilisez cette commande:

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

Pour créer un gros fichier (vide), définissez $INPUT-FILE=/dev/zero.
La taille totale du fichier sera $BLOCK-SIZE * $NUM-BLOCKS.
Le nouveau fichier créé sera $OUTPUT-FILE.

Grundlefleck
la source
Pourquoi as-tu posé la question?
Henry B du
9
J'ai dû chercher la réponse sur Google, alors je l'ai mise ici, pour qu'elle puisse être discutée et tenue à jour ... vous savez, le point de tout le site?
Grundlefleck le
2
Je sais que les gens votent @Grundlefleck pour la putain de XP, mais il a un point - l'un des moyens d'utiliser ce site tel qu'envisagé par Jeff et Joel est de poser une question et une réponse pour quelque chose que vous venez de découvrir.
Paul Tomblin le
3
Merci Paul. Bien que je ne sois pas si dérangé par les points, je suis dérangé par les choses que je trouve sur Google qui peuvent être défectueuses d'une manière que je ne saurais jamais à moins que je ne le demande ici. Les gens devraient se sentir libres de faire en sorte que ma communauté de questions / réponses appartienne s'ils pensent que je suis une putain, hausse les épaules .
Grundlefleck le
2
Pour citer la FAQ "C'est aussi parfaitement bien de poser et de répondre à votre propre question de programmation, mais faites comme si vous étiez sur Jeopardy: formulez-la sous la forme d'une question."
Craig Angus
17

Vous pouvez le faire par programme:

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

Cette approche est particulièrement utile pour mmap par la suite le fichier en mémoire.

utilisez la commande suivante pour vérifier que le fichier a la bonne taille:

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

Faites attention:

# du /tmp/foo.txt

affichera probablement 0 car il est alloué en tant que fichier Sparse s'il est pris en charge par votre système de fichiers.

voir aussi: man 2 open et man 2 truncate

Benedikt Waldvogel
la source
10

vous pourriez faire:

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

Où vous remplacez 100 par le nombre d'octets que vous voulez écrire.

dsm
la source
Et l'octet de remplissage réel également. J'ai besoin de "\ xff" et fonctionne très bien. Merci! :)
Ray
10

Certaines de ces réponses vous permettent d'utiliser /dev/zerola source de vos données. Si votre réseau teste les vitesses de téléchargement, ce n'est peut-être pas la meilleure idée si votre application effectue une compression, un fichier plein de zéros se compresse très bien. Utilisation de cette commande pour générer le fichier

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

Je pourrais compresser upload_testjusqu'à environ 200 octets. Ainsi, vous pourriez vous mettre dans une situation où vous pensez que vous téléchargez un fichier de 10 Ko, mais ce serait en fait beaucoup moins.

Ce que je suggère d'utiliser à la /dev/urandomplace de /dev/zero. Je ne pouvais pas du tout compresser la sortie de /dev/urandombeaucoup.

devin
la source
Mon système embarqué n'a pas /dev/zero, donc /dev/urandomc'est bien.
Fredrick Gauss
9
dd if=/dev/zero of=my_file.txt count=12345
Paul Tomblin
la source
4
Rappelez-vous que la taille de bloc par défaut de dd est de 512 octets, donc cette commande créera un fichier de 12345 * 512 octets.
personne le
4

Il y a beaucoup de réponses, mais aucune n'a bien expliqué ce qui peut être fait d'autre. En regardant dans les pages de manuel pour dd , il est possible de mieux spécifier la taille d'un fichier.

Cela va créer /tmp/zero_big_data_file.bin rempli de zéros, d'une taille de 20 mégaoctets:

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

Cela va créer /tmp/zero_1000bytes_data_file.bin rempli de zéros, d'une taille de 1000 octets:

    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

  • Dans tous les exemples, bs est la taille du bloc et count est le nombre de blocs
  • BLOCKS et BYTES peuvent être suivis des suffixes multiplicatifs suivants: 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, et ainsi de suite pour T, P, E, Z, Y.
BЈовић
la source
3

En tant que commande shell:

< /dev/zero head -c 1048576 >  output
user1772090
la source
3

Cela générera un fichier texte de 4 Mo avec des caractères aléatoires dans le répertoire courant et son nom "4mb.txt" Vous pouvez modifier les paramètres pour générer différentes tailles et noms.

base64 /dev/urandom | head -c 4000000 > 4mb.txt
Berkay92
la source
0

À utiliser fallocatesi vous ne voulez pas attendre le disque.

Exemple:

fallocate -l 100G BigFile

Usage:

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
qin
la source