Compare commits

..

6 Commits
master ... dev

Author SHA1 Message Date
Drew Bonasera e1966ab967 Merge pull request #9 from cskiraly/master
make PiShrink work on/from SD
2016-12-03 21:25:03 -05:00
Csaba Kiraly 900eab7b05 more README 2016-11-24 15:40:23 +01:00
Csaba Kiraly ae83ca90ef add -i flag to shrink first and copy after 2016-11-24 15:38:11 +01:00
Csaba Kiraly bb3982edfd if shrinking from device, copy only the relevant part 2016-11-24 15:37:39 +01:00
Csaba Kiraly e8bf195453 explicitly list device usage in README 2016-11-24 12:00:20 +01:00
Csaba Kiraly 57a69657c8 do not truncate if used directly on the SD 2016-11-24 11:59:51 +01:00
2 changed files with 185 additions and 447 deletions

143
README.md
View File

@ -1,80 +1,63 @@
# PiShrink #
# PiShrink # PiShrink is a bash script that automatically shrink a pi image that will then resize to the max size of the SD card on boot. This will make putting the image back onto the SD card faster and the shrunk images will compress better. The script can also work directly from the SD card reader device.
PiShrink is a bash script that automatically shrink a pi image that will then resize to the max size of the SD card on boot. This will make putting the image back onto the SD card faster and the shrunk images will compress better. `Usage: ./pishrink [-s] [-i] imagefile.img [newimagefile.img]`
In addition the shrunk image can be compressed with gzip and xz to create an even smaller image. Parallel compression of the image ./pishrink [-s] [-i] /dev/sd_device [newimagefile.img]`
using multiple cores is supported.
If the `-s` option is given the script will skip the autoexpanding part of the process. If you specify the `newimagefile.img` parameter, the script will make a copy of `imagefile.img` and work off that. You will need enough space to make a full copy of the image to use that option.
## Usage ## If a device file (e.g. /dev/mmcblk0) is given as parameter, it will shrink the image directly on the SD card. If the `-i` option is given the script will first shrink in place, then prepare a copy. This is especially useful when the first parameter is a device file and space is limited.
``` ## Example ##
Usage: $0 [-adhrsvzZ] imagefile.img [newimagefile.img] ```bash
[user@localhost PiShrink]$ sudo ./pishrink.sh pi.img
-s Don't expand filesystem when image is booted the first time e2fsck 1.42.9 (28-Dec-2013)
-v Be verbose Pass 1: Checking inodes, blocks, and sizes
-r Use advanced filesystem repair option if the normal one fails Pass 2: Checking directory structure
-z Compress image after shrinking with gzip Pass 3: Checking directory connectivity
-Z Compress image after shrinking with xz Pass 4: Checking reference counts
-a Compress image in parallel using multiple cores Pass 5: Checking group summary information
-d Write debug messages in a debug log file /dev/loop1: 88262/1929536 files (0.2% non-contiguous), 842728/7717632 blocks
``` resize2fs 1.42.9 (28-Dec-2013)
resize2fs 1.42.9 (28-Dec-2013)
If you specify the `newimagefile.img` parameter, the script will make a copy of `imagefile.img` and work off that. You will need enough space to make a full copy of the image to use that option. Resizing the filesystem on /dev/loop1 to 773603 (4k) blocks.
Begin pass 2 (max = 100387)
* `-s` prevents automatic filesystem expansion on the images next boot Relocating blocks XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* `-v` enables more verbose output Begin pass 3 (max = 236)
* `-r` will attempt to repair the filesystem using additional options if the normal repair fails Scanning inode table XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* `-z` will compress the image after shrinking using gzip. `.gz` extension will be added to the filename. Begin pass 4 (max = 7348)
* `-Z` will compress the image after shrinking using xz. `.xz` extension will be added to the filename. Updating inode references XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* `-a` will use option -f9 for pigz and option -T0 for xz and compress in parallel. The filesystem on /dev/loop1 is now 773603 blocks long.
* `-d` will create a logfile `pishrink.log` which may help for problem analysis.
Shrunk pi.img from 30G to 3.1G
Default options for compressors can be overwritten by defining PISHRINK_GZIP or PSHRINK_XZ environment variables for gzip and xz. ```
## Example: copying shrinking directly from SD ##
## Prerequisites ##
[user@localhost PiShrink]$ sudo ./pishrink.sh /dev/mmcblk0 pi.img
If you are running PiShrink in VirtualBox you will likely encounter an error if you Copying /dev/mmcblk0 to pi.img...
attempt to use VirtualBox's "Shared Folder" feature. You can copy the image you wish to 30528+0 records in
shrink on to the VM from a Shared Folder, but shrinking directctly from the Shared Folder 30528+0 records out
is know to cause issues. 32010928128 bytes (32 GB, 30 GiB) copied, 587,625 s, 54,5 MB/s
Creating new /etc/rc.local
If using Ubuntu, you will likely see an error about `e2fsck` being out of date and `metadata_csum`. The simplest fix for this is to use Ubuntu 16.10 and up, as it will save you a lot of hassle in the long run. e2fsck 1.42.13 (17-May-2015)
Pass 1: Checking inodes, blocks, and sizes
## Installation ## Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
```bash Pass 4: Checking reference counts
wget https://raw.githubusercontent.com/Drewsif/PiShrink/master/pishrink.sh Pass 5: Checking group summary information
chmod +x pishrink.sh /dev/loop0: 127844/1915424 files (0.1% non-contiguous), 1743616/7798016 blocks
sudo mv pishrink.sh /usr/local/bin resize2fs 1.42.13 (17-May-2015)
``` resize2fs 1.42.13 (17-May-2015)
Resizing the filesystem on /dev/loop0 to 2187260 (4k) blocks.
## Example ## Begin pass 3 (max = 238)
Scanning inode table XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```bash The filesystem on /dev/loop0 is now 2187260 (4k) blocks long.
[user@localhost PiShrink]$ sudo pishrink.sh pi.img Shrunk pi.img from 30G to 8,5G
e2fsck 1.42.9 (28-Dec-2013)
Pass 1: Checking inodes, blocks, and sizes ## Example: shrinking directly on SD ad copying ##
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information ## Contributing ##
/dev/loop1: 88262/1929536 files (0.2% non-contiguous), 842728/7717632 blocks If you find a bug please create an issue for it. If you would like a new feature added, you can create an issue for it but I can't promise that I will get to it.
resize2fs 1.42.9 (28-Dec-2013)
resize2fs 1.42.9 (28-Dec-2013) Pull requests for new features and bug fixes are more than welcome!
Resizing the filesystem on /dev/loop1 to 773603 (4k) blocks.
Begin pass 2 (max = 100387)
Relocating blocks XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 3 (max = 236)
Scanning inode table XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Begin pass 4 (max = 7348)
Updating inode references XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The filesystem on /dev/loop1 is now 773603 blocks long.
Shrunk pi.img from 30G to 3.1G
```
## Contributing ##
If you find a bug please create an issue for it. If you would like a new feature added, you can create an issue for it but I can't promise that I will get to it.
Pull requests for new features and bug fixes are more than welcome!

View File

@ -1,113 +1,89 @@
#!/bin/bash #!/bin/bash
version="v0.1.4" usage() { echo "Usage: $0 [-s] [-i] imagefile.img [newimagefile.img]"; exit -1; }
CURRENT_DIR="$(pwd)" should_skip_autoexpand=false
SCRIPTNAME="${0##*/}" force_inplace_and_copy_after=false
MYNAME="${SCRIPTNAME%.*}"
LOGFILE="${CURRENT_DIR}/${SCRIPTNAME%.*}.log"
REQUIRED_TOOLS="parted losetup tune2fs md5sum e2fsck resize2fs"
ZIPTOOLS=("gzip xz")
declare -A ZIP_PARALLEL_TOOL=( [gzip]="pigz" [xz]="xz" ) # parallel zip tool to use in parallel mode
declare -A ZIP_PARALLEL_OPTIONS=( [gzip]="-f9" [xz]="-T0" ) # options for zip tools in parallel mode
declare -A ZIPEXTENSIONS=( [gzip]="gz" [xz]="xz" ) # extensions of zipped files
function info() { while getopts ":s:i" opt; do
echo "$SCRIPTNAME: $1 ..." case "${opt}" in
} s) should_skip_autoexpand=true ;;
i) force_inplace_and_copy_after=true ;;
*) usage ;;
esac
done
shift $((OPTIND-1))
function error() { #Args
echo -n "$SCRIPTNAME: ERROR occurred in line $1: " img=$1
shift
echo "$@"
}
function cleanup() { #Usage checks
if losetup "$loopback" &>/dev/null; then if [[ -z $img ]]; then
losetup -d "$loopback" usage
fi fi
if [ "$debug" = true ]; then if [[ ! -e $img ]]; then
local old_owner=$(stat -c %u:%g "$src") echo "ERROR: $img is not a file..."
chown "$old_owner" "$LOGFILE" exit -2
fi fi
if (( EUID != 0 )); then
} echo "ERROR: You need to be running as root."
exit -3
function logVariables() {
if [ "$debug" = true ]; then
echo "Line $1" >> "$LOGFILE"
shift
local v var
for var in "$@"; do
eval "v=\$$var"
echo "$var: $v" >> "$LOGFILE"
done
fi
}
function checkFilesystem() {
info "Checking filesystem"
e2fsck -pf "$loopback"
(( $? < 4 )) && return
info "Filesystem error detected!"
info "Trying to recover corrupted filesystem"
e2fsck -y "$loopback"
(( $? < 4 )) && return
if [[ $repair == true ]]; then
info "Trying to recover corrupted filesystem - Phase 2"
e2fsck -fy -b 32768 "$loopback"
(( $? < 4 )) && return
fi fi
error $LINENO "Filesystem recoveries failed. Giving up..."
exit 9
} #Check that what we need is installed
A=`which parted 2>&1`
if (( $? != 0 )); then
echo "ERROR: parted is not installed."
exit -4
fi
function set_autoexpand() { #Copy to new file if requested
#Make pi expand rootfs on next boot if [ -n "$2" -a "$force_inplace_and_copy_after" = false ]; then
mountdir=$(mktemp -d) echo "Copying $1 to $2..."
partprobe "$loopback" if [[ -f $img ]]; then
sleep 3 cp --reflink=auto --sparse=always "$1" "$2"
umount "$loopback" > /dev/null 2>&1 else
mount "$loopback" "$mountdir" -o rw imgsize=`parted -m $img unit B print | tail -1 | cut -d ':' -f 3 | tr -d 'B\n'`
if (( $? != 0 )); then imgsize=`expr $imgsize + 1`
info "Unable to mount loopback, autoexpand will not be enabled" dd if="$1" of="$2" conv=sparse count=$imgsize iflag=count_bytes bs=1M
return fi
fi if (( $? != 0 )); then
echo "ERROR: Could not copy file..."
exit -5
fi
img=$2
fi
if [ ! -d "$mountdir/etc" ]; then #Gather info
info "/etc not found, autoexpand will not be enabled" beforesize=`ls -lah $img | cut -d ' ' -f 5`
umount "$mountdir" partnum=`parted -m $img unit B print | tail -n 1 | cut -d ':' -f 1 | tr -d '\n'`
return partstart=`parted -m $img unit B print | tail -n 1 | cut -d ':' -f 2 | tr -d 'B\n'`
fi loopback=`losetup -f --show -o $partstart $img`
currentsize=`tune2fs -l $loopback | grep 'Block count' | tr -d ' ' | cut -d ':' -f 2 | tr -d '\n'`
blocksize=`tune2fs -l $loopback | grep 'Block size' | tr -d ' ' | cut -d ':' -f 2 | tr -d '\n'`
if [[ ! -f "$mountdir/etc/rc.local" ]]; then #Check if we should make pi expand rootfs on next boot
info "An existing /etc/rc.local was not found, autoexpand may fail..." if [ "$should_skip_autoexpand" = false ]; then
fi #Make pi expand rootfs on next boot
mountdir=`mktemp -d`
mount $loopback $mountdir
if [[ -f "$mountdir/etc/rc.local" ]] && [[ "$(md5sum "$mountdir/etc/rc.local" | cut -d ' ' -f 1)" != "5c286b336c0606ed8e6f87708f7802eb" ]]; then if [ `md5sum $mountdir/etc/rc.local | cut -d ' ' -f 1` != "c4eb22d9aa99915af319287d194d4529" ]; then
echo "Creating new /etc/rc.local" echo Creating new /etc/rc.local
if [ -f "$mountdir/etc/rc.local" ]; then mv $mountdir/etc/rc.local $mountdir/etc/rc.local.bak
mv "$mountdir/etc/rc.local" "$mountdir/etc/rc.local.bak" ###Do not touch the following 6 lines including EOF###
fi cat <<\EOFE > $mountdir/etc/rc.local
#####Do not touch the following lines#####
cat <<\EOF1 > "$mountdir/etc/rc.local"
#!/bin/bash #!/bin/bash
do_expand_rootfs() { do_expand_rootfs() {
ROOT_PART=$(mount | sed -n 's|^/dev/\(.*\) on / .*|\1|p') ROOT_PART=$(cat /proc/cmdline | tr -s ' ' '\n' | grep root= | cut -d '=' -f 2)
if [[ "$ROOT_PART" != /dev/mmcblk0* ]] ; then
PART_NUM=${ROOT_PART#mmcblk0p} echo $ROOT_PART is not an SD card...
if [ "$PART_NUM" = "$ROOT_PART" ]; then
echo "$ROOT_PART is not an SD card. Don't know how to expand"
return 0 return 0
fi fi
PART_NUM=$(echo $ROOT_PART | cut -d 'p' -f 2)
# Get the starting offset of the root partition # Get the starting offset of the root partition
PART_START=$(parted /dev/mmcblk0 -ms unit s p | grep "^${PART_NUM}" | cut -f 2 -d: | sed 's/[^0-9]//g') PART_START=$(fdisk -l /dev/mmcblk0 | grep $ROOT_PART | tr -s ' ' | cut -d ' ' -f 2)
[ "$PART_START" ] || return 1 [ "$PART_START" ] || return 1
# Return value will likely be error for fdisk as it fails to reload the # Return value will likely be error for fdisk as it fails to reload the
# partition table because the root fs is mounted # partition table because the root fs is mounted
@ -120,310 +96,89 @@ p
$PART_NUM $PART_NUM
$PART_START $PART_START
p
w w
EOF EOF
cat <<EOF > /etc/rc.local && cat <<EOF > /etc/rc.local &&
#!/bin/sh #!/bin/sh
echo "Expanding /dev/$ROOT_PART" resize2fs $ROOT_PART
resize2fs /dev/$ROOT_PART rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
rm -f /etc/rc.local; cp -fp /etc/rc.local.bak /etc/rc.local && /etc/rc.local
EOF EOF
reboot reboot
exit exit
} }
raspi_config_expand() {
/usr/bin/env raspi-config --expand-rootfs
if [[ $? != 0 ]]; then
return -1
else
rm -f /etc/rc.local; cp -fp /etc/rc.local.bak /etc/rc.local && /etc/rc.local
reboot
exit
fi
}
raspi_config_expand
echo "WARNING: Using backup expand..."
sleep 5
do_expand_rootfs do_expand_rootfs
echo "ERROR: Expanding failed..." rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
sleep 5
if [[ -f /etc/rc.local.bak ]]; then
cp -fp /etc/rc.local.bak /etc/rc.local
/etc/rc.local
fi
exit 0 exit 0
EOF1 EOFE
#####End no touch zone##### ###End no touch zone###
chmod +x "$mountdir/etc/rc.local" chmod +x $mountdir/etc/rc.local
fi
umount "$mountdir"
}
help() {
local help
read -r -d '' help << EOM
Usage: $0 [-adhrsvzZ] imagefile.img [newimagefile.img]
-s Don't expand filesystem when image is booted the first time
-v Be verbose
-r Use advanced filesystem repair option if the normal one fails
-z Compress image after shrinking with gzip
-Z Compress image after shrinking with xz
-a Compress image in parallel using multiple cores
-d Write debug messages in a debug log file
EOM
echo "$help"
exit 1
}
should_skip_autoexpand=false
debug=false
repair=false
parallel=false
verbose=false
ziptool=""
while getopts ":adhrsvzZ" opt; do
case "${opt}" in
a) parallel=true;;
d) debug=true;;
h) help;;
r) repair=true;;
s) should_skip_autoexpand=true ;;
v) verbose=true;;
z) ziptool="gzip";;
Z) ziptool="xz";;
*) help;;
esac
done
shift $((OPTIND-1))
if [ "$debug" = true ]; then
info "Creating log file $LOGFILE"
rm "$LOGFILE" &>/dev/null
exec 1> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&1)
exec 2> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&2)
fi
echo "${0##*/} $version"
#Args
src="$1"
img="$1"
#Usage checks
if [[ -z "$img" ]]; then
help
fi
if [[ ! -f "$img" ]]; then
error $LINENO "$img is not a file..."
exit 2
fi
if (( EUID != 0 )); then
error $LINENO "You need to be running as root."
exit 3
fi
# set locale to POSIX(English) temporarily
# these locale settings only affect the script and its sub processes
export LANGUAGE=POSIX
export LC_ALL=POSIX
export LANG=POSIX
# check selected compression tool is supported and installed
if [[ -n $ziptool ]]; then
if [[ ! " ${ZIPTOOLS[@]} " =~ $ziptool ]]; then
error $LINENO "$ziptool is an unsupported ziptool."
exit 17
else
if [[ $parallel == true && $ziptool == "gzip" ]]; then
REQUIRED_TOOLS="$REQUIRED_TOOLS pigz"
else
REQUIRED_TOOLS="$REQUIRED_TOOLS $ziptool"
fi
fi
fi
#Check that what we need is installed
for command in $REQUIRED_TOOLS; do
command -v $command >/dev/null 2>&1
if (( $? != 0 )); then
error $LINENO "$command is not installed."
exit 4
fi fi
done umount $mountdir
#Copy to new file if requested
if [ -n "$2" ]; then
f="$2"
if [[ -n $ziptool && "${f##*.}" == "${ZIPEXTENSIONS[$ziptool]}" ]]; then # remove zip extension if zip requested because zip tool will complain about extension
f="${f%.*}"
fi
info "Copying $1 to $f..."
cp --reflink=auto --sparse=always "$1" "$f"
if (( $? != 0 )); then
error $LINENO "Could not copy file..."
exit 5
fi
old_owner=$(stat -c %u:%g "$1")
chown "$old_owner" "$f"
img="$f"
fi
# cleanup at script exit
trap cleanup EXIT
#Gather info
info "Gathering data"
beforesize="$(ls -lh "$img" | cut -d ' ' -f 5)"
parted_output="$(parted -ms "$img" unit B print)"
rc=$?
if (( $rc )); then
error $LINENO "parted failed with rc $rc"
info "Possibly invalid image. Run 'parted $img unit B print' manually to investigate"
exit 6
fi
partnum="$(echo "$parted_output" | tail -n 1 | cut -d ':' -f 1)"
partstart="$(echo "$parted_output" | tail -n 1 | cut -d ':' -f 2 | tr -d 'B')"
if [ -z "$(parted -s "$img" unit B print | grep "$partstart" | grep logical)" ]; then
parttype="primary"
else else
parttype="logical" echo Skipping autoexpanding process...
fi
loopback="$(losetup -f --show -o "$partstart" "$img")"
tune2fs_output="$(tune2fs -l "$loopback")"
rc=$?
if (( $rc )); then
echo "$tune2fs_output"
error $LINENO "tune2fs failed. Unable to shrink this type of image"
exit 7
fi
currentsize="$(echo "$tune2fs_output" | grep '^Block count:' | tr -d ' ' | cut -d ':' -f 2)"
blocksize="$(echo "$tune2fs_output" | grep '^Block size:' | tr -d ' ' | cut -d ':' -f 2)"
logVariables $LINENO beforesize parted_output partnum partstart parttype tune2fs_output currentsize blocksize
#Check if we should make pi expand rootfs on next boot
if [ "$parttype" == "logical" ]; then
echo "WARNING: PiShrink does not yet support autoexpanding of this type of image"
elif [ "$should_skip_autoexpand" = false ]; then
set_autoexpand
else
echo "Skipping autoexpanding process..."
fi fi
#Make sure filesystem is ok #Make sure filesystem is ok
checkFilesystem e2fsck -f $loopback
minsize=`resize2fs -P $loopback | cut -d ':' -f 2 | tr -d ' ' | tr -d '\n'`
if ! minsize=$(resize2fs -P "$loopback"); then
rc=$?
error $LINENO "resize2fs failed with rc $rc"
exit 10
fi
minsize=$(cut -d ':' -f 2 <<< "$minsize" | tr -d ' ')
logVariables $LINENO currentsize minsize
if [[ $currentsize -eq $minsize ]]; then if [[ $currentsize -eq $minsize ]]; then
error $LINENO "Image already shrunk to smallest size" echo ERROR: Image already shrunk to smallest size
exit 11 exit -6
fi fi
#Add some free space to the end of the filesystem #Add some free space to the end of the filesystem
extra_space=$(($currentsize - $minsize)) if [[ `expr $currentsize - $minsize - 5000` -gt 0 ]]; then
logVariables $LINENO extra_space minsize=`expr $minsize + 5000 | tr -d '\n'`
for space in 5000 1000 100; do elif [[ `expr $currentsize - $minsize - 1000` -gt 0 ]]; then
if [[ $extra_space -gt $space ]]; then minsize=`expr $minsize + 1000 | tr -d '\n'`
minsize=$(($minsize + $space)) elif [[ `expr $currentsize - $minsize - 100` -gt 0 ]]; then
break minsize=`expr $minsize + 100 | tr -d '\n'`
fi fi
done
logVariables $LINENO minsize
#Shrink filesystem #Shrink filesystem
info "Shrinking filesystem" resize2fs -p $loopback $minsize
resize2fs -p "$loopback" $minsize if [[ $? != 0 ]]; then
rc=$? echo ERROR: resize2fs failed...
if (( $rc )); then mount $loopback $mountdir
error $LINENO "resize2fs failed with rc $rc" mv $mountdir/etc/rc.local.bak $mountdir/etc/rc.local
mount "$loopback" "$mountdir" umount $mountdir
mv "$mountdir/etc/rc.local.bak" "$mountdir/etc/rc.local" losetup -d $loopback
umount "$mountdir" exit $rc
losetup -d "$loopback"
exit 12
fi fi
sleep 1 sleep 1
#Shrink partition #Shrink partition
partnewsize=$(($minsize * $blocksize)) losetup -d $loopback
newpartend=$(($partstart + $partnewsize)) partnewsize=`expr $minsize \* $blocksize | tr -d '\n'`
logVariables $LINENO partnewsize newpartend newpartend=`expr $partstart + $partnewsize | tr -d '\n'`
parted -s -a minimal "$img" rm "$partnum" part1=`parted $img rm $partnum`
rc=$? part2=`parted $img unit B mkpart primary $partstart $newpartend`
if (( $rc )); then
error $LINENO "parted failed with rc $rc"
exit 13
fi
parted -s "$img" unit B mkpart "$parttype" "$partstart" "$newpartend"
rc=$?
if (( $rc )); then
error $LINENO "parted failed with rc $rc"
exit 14
fi
#Truncate the file #Truncate the file
info "Shrinking image" if [[ -f $img ]]; then
endresult=$(parted -ms "$img" unit B print free) endresult=`parted -m $img unit B print free | tail -1 | cut -d ':' -f 2 | tr -d 'B\n'`
rc=$? truncate -s $endresult $img
if (( $rc )); then aftersize=`ls -lah $img | cut -d ' ' -f 5`
error $LINENO "parted failed with rc $rc" echo "Shrunk $img from $beforesize to $aftersize"
exit 15
fi fi
endresult=$(tail -1 <<< "$endresult" | cut -d ':' -f 2 | tr -d 'B') #Copy to new file if requested
logVariables $LINENO endresult if [ -n "$2" -a "$force_inplace_and_copy_after" = true ]; then
truncate -s "$endresult" "$img" echo "Copying $1 to $2..."
rc=$? if [[ -f $img ]]; then
if (( $rc )); then cp --reflink=auto --sparse=always "$1" "$2"
error $LINENO "trunate failed with rc $rc" else
exit 16 imgsize=`parted -m $img unit B print | tail -1 | cut -d ':' -f 3 | tr -d 'B\n'`
imgsize=`expr $imgsize + 1`
dd if="$1" of="$2" conv=sparse count=$imgsize iflag=count_bytes bs=1M
fi
if (( $? != 0 )); then
echo "ERROR: Could not copy file..."
exit -5
fi
img=$2
fi fi
# handle compression
if [[ -n $ziptool ]]; then
options=""
envVarname="${MYNAME^^}_${ziptool^^}" # PISHRINK_GZIP or PISHRINK_XZ environment variables allow to override all options for gzip or xz
[[ $parallel == true ]] && options="${ZIP_PARALLEL_OPTIONS[$ziptool]}"
[[ -v $envVarname ]] && options="${!envVarname}" # if environment variable defined use these options
[[ $verbose == true ]] && options="$options -v" # add verbose flag if requested
if [[ $parallel == true ]]; then
parallel_tool="${ZIP_PARALLEL_TOOL[$ziptool]}"
info "Using $parallel_tool on the shrunk image"
if ! $parallel_tool ${options} "$img"; then
rc=$?
error $LINENO "$parallel_tool failed with rc $rc"
exit 18
fi
else # sequential
info "Using $ziptool on the shrunk image"
if ! $ziptool ${options} "$img"; then
rc=$?
error $LINENO "$ziptool failed with rc $rc"
exit 19
fi
fi
img=$img.${ZIPEXTENSIONS[$ziptool]}
fi
aftersize=$(ls -lh "$img" | cut -d ' ' -f 5)
logVariables $LINENO aftersize
info "Shrunk $img from $beforesize to $aftersize"