Existe-t-il des outils sous Linux pour diviser un fichier en place?

J'ai un fichier 500G que je voudrais diviser sous Linux, mais je n'ai pas d'autre 500G disponible pour fonctionner split(1).

Existe-t-il un outil ou un script qui divisera le fichier en place en morceaux 1G tout en utilisant un espace supplémentaire minimal?

#!/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 s'est correctement exécuté après le démontage et le remontage.

J'ai trouvé le script @whitequark vraiment utile. Mais je voulais diviser une image disque de 500 Go en gros morceaux d'environ 50 Go chacun. De cette façon, le script a échoué, car ddil ne peut pas gérer un bsparamètre aussi important .

J'ai donc personnalisé le script pour créer bs=1Met demander des mégaoctets au lieu d'octets. Maintenant, je peux diviser en place et en gros morceaux en utilisant, par exemple, 50000pour 50 Go.

#! / bin / bash
# (c) whitequark 2010
# (c) dertalai 2015 (modifications minimes)

set -e

si [$ #! = 2]; ensuite
  echo "Utilisation: $ 0"
  echo "Ce script divisera le fichier en plusieurs parties, à partir de"
  echo "la fin et tronquer le fichier d'origine en cours."
  echo "La taille de la pièce est spécifiée en mégaoctets (1 Mo = 1048576 octets)."
  echo "Utilisez à vos risques et périls."
  sortie 0
Fi

nom de fichier = 1 $
# partsize = $ 2
partsizeMB = $ 2
partsize = $ (($ 2 * 1048576))

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

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

  echo "Division de la partie $ _part"
  echo $ (($ partsize * ($ _part - 1)))
  dd if = "$ {filename}" of = "$ {filename}. $ (printf '% 04d' $ _part)" \
      count = $ partsizeMB bs = 1M skip = $ ((($ _ part - 1) * $ partsizeMB))
  echo "Tronquer le fichier source"
  tronquer "$ {filename}" --size = "- $ _ size"
}

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

pour i en $ (seq $ parties -1 1); faire
  do_split $ i $ partsize
terminé

rm "$ {filename}"

Avez-vous déjà le fichier de 500 Go? Si vous générez un fichier de 500 Go en archivant un dossier ou un disque, puis en essayant de le diviser, vous pouvez le diviser à la volée en canalisant la sortie de tar (ou tout ce que vous utilisez) en fractionnement:

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

Cela fera des divisions au format DVD d'une archive de ma base de données Time Machine. Cependant, il les fait tous à la fois, ce qui signifie qu'il ne fait vraiment pas ce que vous recherchez.

Voir ma question ici pour plus d'informations. Le script de Whitequark pourrait être utile là-bas avec quelques légères modifications! Je vais devoir l'essayer.