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

the linux command line epub

Question

Para propósitos 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?

Answer 1

Algunas de estas respuestas lo tienen usando /dev/zero para la fuente de sus datos. Si la velocidad de carga de su red de prueba, esta puede no ser la mejor idea si su aplicación está realizando 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_test hasta unos 200 bytes. Así que podrías ponerte en una situación en la que creas que estás cargando un archivo de 10 KB pero en realidad sería mucho menos.

Lo que sugiero es usar /dev/urandom lugar de /dev/zero . No pude comprimir mucho la salida de /dev/urandom .

Answer 2

Como comando de shell:

< /dev/zero head -c 1048576 >  output

Answer 3

En OSX (y Solaris, al parecer), el comando mkfile está disponible:

mkfile 10g big_file

Esto hace un archivo de 10 GB llamado "big_file". Encontrado este enfoque here.

Answer 4

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

Answer 5

Hay muchas respuestas, pero ninguna explica muy bien qué más se puede hacer. Al buscar 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 del bloque y el recuento es el número de bloques
• BLOCKS 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.

Answer 6

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.

Answer 7

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

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

Se debe indicar que truncate en un sistema de archivos que soporte archivos dispersos creará un archivo disperso y no se fallocate . Un archivo disperso es aquel en el que las unidades de asignación que componen el archivo no se asignan realmente hasta que se utilizan. Sin embargo, los metadatos del archivo ocuparán un espacio considerable, pero probablemente no estén cerca del tamaño real del archivo. Debe consultar los recursos sobre los archivos dispersos para obtener más información, ya que existen ventajas y desventajas para este tipo de archivo. Un archivo no disperso tiene asignados sus bloques (unidades de asignación) con anticipación, lo que significa que el espacio está reservado en la medida en que lo vea el sistema de archivos. También fallocate o truncate no establecerá el contenido del archivo a un valor especificado como dd , en su lugar el contenido de un archivo asignado con fallocate o truncate puede ser cualquier valor de basura que existió en las unidades asignadas durante la creación y este comportamiento puede o no ser deseado El dd es el más lento porque en realidad escribe el valor o el fragmento de datos en toda la secuencia de archivos tal como se especifica con sus opciones de línea de comando.

Este comportamiento podría ser potencialmente diferente, según el sistema de archivos utilizado y la conformidad de ese sistema de archivos con cualquier estándar o especificación. Por lo tanto, se recomienda realizar una investigación adecuada para garantizar que se utiliza el método apropiado.

Answer 8

Puedes hacerlo programáticamente:

#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 mmap 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 imprima 0 porque está asignado como archivo disperso si es compatible con su sistema de archivos.

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

Answer 9

Solo para seguir Tom''s publicación Tom''s , puedes usar dd para crear también 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 las Unixes: los datos no se escribirán en el disco, o ocuparán espacio hasta que se escriba algo distinto de cero.

Answer 10

Supongo que el enfoque más eficiente implicaría crear el archivo usando open (con los O_CREAT y O_WRONLY , a menos que desee leer del archivo en el mismo programa) y configurar el tamaño con ftruncate .

Answer 11

Use este comando:

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

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

Answer 12

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

Answer 13

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

Donde file_size es el tamaño de su archivo de prueba en bytes