¿Hay alguna herramienta en Linux para dividir un archivo en su lugar?

Tengo un archivo 500G que me gustaría dividir en Linux, pero no tengo otros 500G libres para ejecutar split(1).

¿Existe una herramienta o secuencia de comandos que dividirá el archivo en el lugar en trozos de 1G mientras se utiliza un espacio adicional mínimo?

#!/bin/bash
# (c) whitequark 2010

set -e

if [ $# != 2 ]; then
  echo "Usage: $0 <filename> <part size>"
  echo "  This script will split file to multiple parts, starting from"
  echo "  the end, and truncating the original file in process."
  echo "  Part size is specified in bytes."
  echo "  Use at your own risk."
  exit 0
fi

filename=$1
partsize=$2

size=$(stat -c '%s' "${filename}")
parts=$(($size / $partsize))

do_split() {
  _part=$1
  _size=$2

  echo "Splitting part $_part"
  echo $(($partsize * ($_part - 1)))
  dd if="${filename}" of="${filename}.$(printf '%04d' $_part)" \
      count=1 bs=$partsize skip=$(($_part - 1))
  echo "Truncating source file"
  truncate "${filename}" --size="-$_size"
}

lastsize=$(($size % $partsize))
if [ $lastsize != 0 ]; then
  do_split $(($parts + 1)) $lastsize
fi

for i in $(seq $parts -1 1); do
  do_split $i $partsize
done

rm "${filename}"

gedit se ejecutó con éxito después de desarmarlo y volverlo a armar

Encontré el script @whitequark realmente útil. Pero quería dividir una imagen de disco de 500 GB en algunos fragmentos grandes de aproximadamente 50 GB cada uno. De esta manera, el script falló, ya ddque no puede manejar un bsparámetro tan grande .

Así que personalicé el script para hacer bs=1My pedir megabytes en lugar de bytes. Ahora puedo dividirme en su lugar y en trozos realmente grandes usando, por ejemplo, 5000050 GB.

#! / bin / bash
# (c) whitequark 2010
# (c) dertalai 2015 (modificaciones mínimas)

conjunto -e

si [$ #! = 2]; luego
  echo "Uso: $ 0"
  echo "Este script dividirá el archivo en varias partes, comenzando desde"
  echo "al final, y truncando el archivo original en proceso".
  echo "El tamaño de la pieza se especifica en megabytes (1 MB = 1048576 bytes)".
  echo "Use bajo su propio riesgo".
  salida 0
fi

nombre de archivo = $ 1
# partes = $ 2
partsizeMB = $ 2
parte = $ (($ 2 * 1048576))

size = $ (stat -c '% s' "$ {filename}")
partes = $ (($ tamaño / $ partes))

do_split () {
  _parte = $ 1
  _ tamaño = $ 2

  echo "Parte dividida $ _part"
  echo $ (($ partes * ($ _part - 1)))
  dd if = "$ {filename}" of = "$ {filename}. $ (printf '% 04d' $ _part)" \
      count = $ partsizeMB bs = 1M skip = $ ((($ _ part - 1) * $ partsizeMB))
  echo "Truncar archivo fuente"
  truncar "$ {filename}" --size = "- $ _ size"
}

lastsize = $ (($ size% $ partsize))
if [$ lastsize! = 0]; luego
  do_split $ (($ partes + 1)) $ lastsize
fi

para i en $ (seq $ partes -1 1); hacer
  do_split $ i $ partsize
hecho

rm "$ {filename}"

¿Ya tienes el archivo de 500 GB? Si está generando un archivo de 500GB archivando una carpeta o disco, y luego tratando de dividirlo, puede dividirlo sobre la marcha al dividir la salida de tar (o lo que esté usando) en división:

sudo tar cvjsp /Volumes/BackupDisk/Backups.backupdb/ | \
     split -d -b 4480m - Backups.backupdb.tar.bz2.

Esto hará divisiones del tamaño de un DVD de un archivo de mi base de datos de Time Machine. Sin embargo, los hace todos a la vez, lo que significa que realmente no hace lo que estás buscando.

Vea mi pregunta aquí para más información. ¡El guión de Whitequark podría ser útil allí con alguna ligera modificación! Tendré que intentarlo.