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

À 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?

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

Où file_sizeest la taille de votre fichier de test en octets

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.

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.

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.

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.

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

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.

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.

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

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.

En tant que commande shell:

< /dev/zero head -c 1048576 >  output

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

À 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