web-dev-qa-db-fra.com

Comment créer un fichier avec 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?

linuxcommand-line
141
Grundlefleck
dd if=/dev/zero of=upload_test bs=file_size count=1

Où file_size est la taille en octets de votre fichier de test

174
Ilya Kochetov

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 est nécessaire de préciser que truncate sur un système de fichiers prenant en charge des fichiers fragmentés crée un fichier fragmenté et que fallocate ne pas. Un fichier fragmenté est un fichier dans lequel les unités d'allocation composant le fichier ne sont pas réellement allouées tant qu'elles ne sont pas utilisées. Les métadonnées pour le fichier occuperont cependant un espace considérable, mais probablement pas près de la taille réelle du fichier. Vous devriez consulter les ressources sur les fichiers fragmentés pour plus d'informations, car ce type de fichier présente des avantages et des inconvénients. Un bloc non fragmenté a ses blocs (unités d'allocation) alloués à l'avance, ce qui signifie que l'espace est réservé dans la mesure où le système de fichiers le voit. De plus, fallocate ni truncate ne définira pas le contenu du fichier avec une valeur spécifiée comme dd au lieu de cela, le contenu d'un fichier alloué avec fallocate ou truncate peut être une valeur de corbeille qui existait déjà dans les unités allouées lors de la création et ce comportement peut ne pas être souhaité. dd est le plus lent, car il écrit réellement la valeur ou le bloc de données dans le flux de fichiers entier, comme spécifié avec ses options de ligne de commande.

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

152
jørgensen

Juste pour faire un suivi Tom's post, vous pouvez également utiliser dd pour créer des fichiers fragmentés:

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

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

40
Brian

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

mkfile 10g big_file

Cela crée un fichier de 10 Go nommé "big_file". Trouvé cette approche ici.

21
steve

Utilisez cette commande:

 dd si = $ FICHIER-ENTREE de = $ FICHIER-DE-SORTIE 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.

20
Grundlefleck

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 ensuite mmap le fichier en mémoire.

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

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

Faites attention:

# du /tmp/foo.txt

va probablement imprimer 0 car il est alloué en tant que fichier fragmenté s'il est supporté par votre système de fichiers.

voir aussi: homme 2 ouvert et homme 2 tronqué

17
Benedikt Waldvogel

vous pourriez faire:

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

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

10
dsm

Certaines de ces réponses vous ont utilisé /dev/zero pour la source de vos données. Si vous testez les vitesses de téléchargement sur le réseau, il se peut que ce ne soit pas la meilleure idée si votre application effectue une compression, un fichier plein de zéros se compresse vraiment bien. Utiliser cette commande pour générer le fichier

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

Je pourrais compresser upload_test jusqu’à 200 octets environ. Donc, vous pourriez vous mettre dans une situation où vous pensez que vous téléchargez un fichier de 10Ko mais ce serait en réalité beaucoup moins.

Ce que je suggère est d'utiliser /dev/urandom au lieu de /dev/zero. Je ne pouvais pas compresser la sortie de /dev/urandom beaucoup du tout.

10
devin
dd if=/dev/zero of=my_file.txt count=12345
9
Paul Tomblin

Il y a beaucoup de réponses, mais aucune n'a bien expliqué ce qu'il est possible de faire d'autre. En regardant dans 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 de 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.
3
BЈовић

En tant que commande Shell:

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

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
3
Berkay92