Escribe el mismo file varias veces en un file usando dd

Estoy intentando crear files ficticios grandes en una unidad usando dd. Actualmente estoy haciendo esto:

#!/bin/bash writeFile(){ #$1 - destination directory/filename, $2 - source filepath $3 - blocksize, $4 - blockcount $5 - log file name if [ "$#" -ne 5 ]; then echo "Bad number of args - Should be 4, not $#" return 1; fi dest_filepath=$1 src_filepath=$2 block_size=$3 block_count=$4 log_file=$5 int_regex='^[0-9]+$' file_size=$(($block_size * $block_count)) src_file_size=`ls -l $src_filepath | awk '{print $5}'` full_iter=0 while [[ $file_size -ge $src_file_size ]]; do file_size=$((file_size - $src_file_size)) full_iter=$((full_iter + 1)) done section_block_count=$(($src_file_size / $block_size)) echo $section_block_count $block_size topping_off_block_count=$(($file_size / $block_size)) dest_dir=$(dirname $dest_filepath) if [ -d "$dest_dir" ] && [ -r $src_filepath ] && [[ $block_size =~ $int_regex ]] && [[ $block_count =~ $int_regex ]]; then data_written=0 for (( i=0 ; i < $full_iter ; i=$((i+1)) )); do (time dd of=$dest_filepath if=$src_filepath bs=$block_size count=$section_block_count seek=$data_written) >> $log_file 2>&1 #Output going to external file data_written=$(($data_written + $src_file_size +1 )) echo $data_written done if [[ $file_size -gt 0 ]]; then (time dd of=$dest_filepath if=$src_filepath bs=$block_size count=$topping_off_block_count seek=$data_written) >> $log_file 2>&1 & #Output going to external file fi return 0; fi return 1; } 

Sin embargo, esto no funciona, ya que solo está escribiendo una vez desde src_filepath , o escribiendo sobre la misma parte del file varias veces, no sé cómo encontrar la diferencia. En este caso particular, lo que estoy haciendo es escribir desde un file de 256MB 4 veces para crear un solo file de 1GB, pero quiero mantenerlo genérico para que pueda escribir cualquier tamaño desde y hacia.

El objective es fragmentar un disco duro y medir la salida de dd (velocidad de transferencia específicamente) y el time que tomó.

Estoy en un sistema integrado con funcionalidad limitada, y el sistema operativo es una versión muy baja de linux que usa busybox.

¿Cómo modifico esto para que escriba el file de tamaño correcto?

respondiendo a los comentarios: conv=notrunc hace que dd no se trunque, pero no lo hace search hasta el final. (Deja fuera O_TRUNC , pero no agrega O_APPEND en la llamada al sistema open(2) ).

Respondiendo a la pregunta: Si insiste en usar dd lugar de cat , entonces obtenga el shell para abrir el file de salida para anexar, y escriba dd en su stdout.

dd if=src bs=128k count=$count of=/dev/stdout >> dest 2>> log

Además, si está intentando fragmentar su disco, podría hacer un montón de fallocate(1) de fallocate(1) para usar espacio, y luego comenzar a usar dd una vez que el disco esté casi lleno. El progtwig de fallocate de util-linux es un front-end simple para la llamada al sistema de fallocate(2) .

xfs, por ejemplo, detectará el patrón abrir, agregar y dejar su espacio preasignado especulativamente más allá de EOF asignado durante unos segundos después del cierre. Por lo tanto, en XFS, un bucle de anexar al mismo file repetidamente no producirá tanta fragmentación como la escritura de muchos files pequeños.

Estás en un sistema integrado, así que supongo que no estás usando xfs. En ese caso, aún podría ver less fragmentación desde su cierre / reapertura / escritura más de lo que cabría esperar, con un sistema de files decentemente inteligente. Tal vez sincronizar entre cada escritura, esperar a que el FS asigne y escriba todos sus datos, antes de hacerle saber que viene más.