¿Cómo crear un archivo con un tamaño dado en Linux?

Para fines de prueba, tengo que generar un archivo de cierto tamaño (para probar un límite de carga).

¿Qué es un comando para crear un archivo de cierto tamaño en Linux?

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

¿Dónde file_sizeestá el tamaño de su archivo de prueba en bytes?

Por favor, lo moderno es más fácil y más rápido. En Linux, (elige uno)

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

Es necesario decir que truncateen un sistema de archivos que admite archivos dispersos creará un archivo disperso y fallocateno lo hará. Un archivo disperso es aquel en el que las unidades de asignación que componen el archivo no se asignan realmente hasta que se usan. Sin embargo, los metadatos para el archivo ocuparán un espacio considerable, pero probablemente no cerca del tamaño real del archivo. Debe consultar recursos sobre archivos dispersos para obtener más información, ya que existen ventajas y desventajas para este tipo de archivo. Un archivo no disperso tiene sus bloques (unidades de asignación) asignados con anticipación, lo que significa que el espacio está reservado hasta donde el sistema de archivos lo ve. Además fallocate, ni truncateno se establecerá el contenido del archivo a un valor especificado como dd, en cambio, el contenido de un archivo asignado con fallocateo truncatepuede ser cualquier valor de papelera que haya existido en las unidades asignadas durante la creación y este comportamiento puede o no ser deseado. El ddes el más lento porque en realidad escribe el valor o el fragmento de datos en toda la secuencia de archivos como se especifica con sus opciones de línea de comandos.

Este comportamiento podría ser diferente, dependiendo del sistema de archivos utilizado y la conformidad de ese sistema de archivos con cualquier estándar o especificación. Por lo tanto, se aconseja que se realice una investigación adecuada para garantizar que se utilice el método apropiado.

Solo para seguir la publicación de Tom , también puedes usar dd para crear archivos dispersos:

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

Esto creará un archivo con un "agujero" en la mayoría de los Unixes: los datos en realidad no se escribirán en el disco ni ocuparán espacio hasta que se escriba algo distinto de cero.

En OSX (y Solaris, aparentemente), el mkfilecomando también está disponible:

mkfile 10g big_file

Esto crea un archivo de 10 GB llamado "big_file". Encontré este enfoque aquí.

Usa este comando:

dd if = $ ARCHIVO DE ENTRADA de = $ ARCHIVO DE SALIDA bs = $ BLOCK-SIZE count = $ NUM-BLOCKS

Para crear un archivo grande (vacío), establezca $INPUT-FILE=/dev/zero.
El tamaño total del archivo será $BLOCK-SIZE * $NUM-BLOCKS.
Nuevo archivo creado será $OUTPUT-FILE.

Puedes hacerlo mediante programación:

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

Este enfoque es especialmente útil para posteriormente mapear el archivo en la memoria.

use el siguiente comando para verificar que el archivo tenga el tamaño correcto:

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

Ten cuidado:

# du /tmp/foo.txt

probablemente imprimirá 0 porque se asigna como archivo Sparse si es compatible con su sistema de archivos

ver también: hombre 2 abierto y hombre 2 truncado

Podrías hacerlo:

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

Donde reemplaza 100 con el número de bytes que desea escribir.

Algunas de estas respuestas lo tienen usando /dev/zeropara la fuente de sus datos. Si prueba las velocidades de carga de la red, puede que esta no sea la mejor idea si su aplicación está haciendo alguna compresión, un archivo lleno de ceros se comprime muy bien. Usando este comando para generar el archivo

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

Podría comprimir upload_testhasta unos 200 bytes. Por lo tanto, podría ponerse en una situación en la que cree que está cargando un archivo de 10 KB, pero en realidad sería mucho menos.

Lo que sugiero es usar en /dev/urandomlugar de /dev/zero. No pude comprimir la salida de /dev/urandommucho en absoluto.

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

Hay muchas respuestas, pero ninguna explicó bien qué más se puede hacer. Buscando en las páginas man para dd , es posible especificar mejor el tamaño de un archivo.

Esto va a crear /tmp/zero_big_data_file.bin lleno de ceros, que tiene un tamaño de 20 megabytes:

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

Esto va a crear /tmp/zero_1000bytes_data_file.bin lleno de ceros, que tiene un tamaño de 1000 bytes:

    dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin  bs=1kB count=1

o

    dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin  bs=1000 count=1

• En todos los ejemplos, bs es el tamaño de bloque y count es el número de bloques
• Los BLOQUES y BYTES pueden ir seguidos de los siguientes sufijos multiplicativos: 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, y así sucesivamente para T, P, E, Z, Y.

Como comando de shell:

< /dev/zero head -c 1048576 >  output

Esto generará un archivo de texto de 4 MB con caracteres aleatorios en el directorio actual y su nombre "4mb.txt". Puede cambiar los parámetros para generar diferentes tamaños y nombres.

base64 /dev/urandom | head -c 4000000 > 4mb.txt

Úselo fallocatesi no quiere esperar al disco.

Ejemplo:

fallocate -l 100G BigFile

Uso:

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