Fixes for rc.local issues

- Display warning when no existing /etc/rc.local is found
- Only try to run old /etc/rc.local if it actually exists

Closes #151
Closes #267

README.md

@@ -1,63 +1,80 @@
-# 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 #
-
+
-`Usage: ./pishrink [-s] [-i] imagefile.img [newimagefile.img]`
+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.
-        ./pishrink [-s] [-i] /dev/sd_device [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
-
+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.
+
-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.
+## Usage ##
-
+
-## Example ##
+```
-```bash
+Usage: $0 [-adhrsvzZ] imagefile.img [newimagefile.img]
-[user@localhost PiShrink]$ sudo ./pishrink.sh pi.img
+
-e2fsck 1.42.9 (28-Dec-2013)
+  -s         Don't expand filesystem when image is booted the first time
-Pass 1: Checking inodes, blocks, and sizes
+  -v         Be verbose
-Pass 2: Checking directory structure
+  -r         Use advanced filesystem repair option if the normal one fails
-Pass 3: Checking directory connectivity
+  -z         Compress image after shrinking with gzip
-Pass 4: Checking reference counts
+  -Z         Compress image after shrinking with xz
-Pass 5: Checking group summary information
+  -a         Compress image in parallel using multiple cores
-/dev/loop1: 88262/1929536 files (0.2% non-contiguous), 842728/7717632 blocks
+  -d         Write debug messages in a debug log file
-resize2fs 1.42.9 (28-Dec-2013)
+```
-resize2fs 1.42.9 (28-Dec-2013)
+
-Resizing the filesystem on /dev/loop1 to 773603 (4k) blocks.
+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.
-Begin pass 2 (max = 100387)
+
-Relocating blocks             XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+* `-s` prevents automatic filesystem expansion on the images next boot
-Begin pass 3 (max = 236)
+* `-v` enables more verbose output
-Scanning inode table          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+* `-r` will attempt to repair the filesystem using additional options if the normal repair fails
-Begin pass 4 (max = 7348)
+* `-z` will compress the image after shrinking using gzip. `.gz` extension will be added to the filename.
-Updating inode references     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+* `-Z` will compress the image after shrinking using xz. `.xz` extension will be added to the filename.
-The filesystem on /dev/loop1 is now 773603 blocks long.
+* `-a` will use option -f9 for pigz and option -T0 for xz and compress in parallel.
-
+* `-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
+
-Copying /dev/mmcblk0 to pi.img...
+If you are running PiShrink in VirtualBox you will likely encounter an error if you
-30528+0 records in
+attempt to use VirtualBox's "Shared Folder" feature. You can copy the image you wish to
-30528+0 records out
+shrink on to the VM from a Shared Folder, but shrinking directctly from the Shared Folder
-32010928128 bytes (32 GB, 30 GiB) copied, 587,625 s, 54,5 MB/s
+is know to cause issues.
-Creating new /etc/rc.local
+
-e2fsck 1.42.13 (17-May-2015)
+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.
-Pass 1: Checking inodes, blocks, and sizes
+
-Pass 2: Checking directory structure
+## Installation ##
-Pass 3: Checking directory connectivity
+
-Pass 4: Checking reference counts
+```bash
-Pass 5: Checking group summary information
+wget https://raw.githubusercontent.com/Drewsif/PiShrink/master/pishrink.sh
-/dev/loop0: 127844/1915424 files (0.1% non-contiguous), 1743616/7798016 blocks
+chmod +x pishrink.sh
-resize2fs 1.42.13 (17-May-2015)
+sudo mv pishrink.sh /usr/local/bin
-resize2fs 1.42.13 (17-May-2015)
+```
-Resizing the filesystem on /dev/loop0 to 2187260 (4k) blocks.
+
-Begin pass 3 (max = 238)
+## Example ##
-Scanning inode table          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
-The filesystem on /dev/loop0 is now 2187260 (4k) blocks long.
+```bash
-Shrunk pi.img from 30G to 8,5G
+[user@localhost PiShrink]$ sudo pishrink.sh pi.img
-
+e2fsck 1.42.9 (28-Dec-2013)
-## Example: shrinking directly on SD ad copying ##
+Pass 1: Checking inodes, blocks, and sizes
-
+Pass 2: Checking directory structure
-
+Pass 3: Checking directory connectivity
-
+Pass 4: Checking reference counts
-## Contributing ##
+Pass 5: Checking group summary information
-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.
+/dev/loop1: 88262/1929536 files (0.2% non-contiguous), 842728/7717632 blocks
-
+resize2fs 1.42.9 (28-Dec-2013)
-Pull requests for new features and bug fixes are more than welcome!
+resize2fs 1.42.9 (28-Dec-2013)
+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!

pishrink.sh

@@ -1,89 +1,113 @@
 #!/bin/bash
 
-usage() { echo "Usage: $0 [-s] [-i] imagefile.img [newimagefile.img]"; exit -1; }
+version="v0.1.4"
 
-should_skip_autoexpand=false
+CURRENT_DIR="$(pwd)"
-force_inplace_and_copy_after=false
+SCRIPTNAME="${0##*/}"
+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
 
-while getopts ":s:i" opt; do
+function info() {
-  case "${opt}" in
+	echo "$SCRIPTNAME: $1 ..."
-    s) should_skip_autoexpand=true ;;
+}
-    i) force_inplace_and_copy_after=true ;;
-    *) usage ;;
-  esac
-done
-shift $((OPTIND-1))
 
-#Args
+function error() {
-img=$1
+	echo -n "$SCRIPTNAME: ERROR occurred in line $1: "
+	shift
+	echo "$@"
+}
 
-#Usage checks
+function cleanup() {
-if [[ -z $img ]]; then
+	if losetup "$loopback" &>/dev/null; then
-  usage
+		losetup -d "$loopback"
-fi
+	fi
-if [[ ! -e $img ]]; then
+	if [ "$debug" = true ]; then
-  echo "ERROR: $img is not a file..."
+		local old_owner=$(stat -c %u:%g "$src")
-  exit -2
+		chown "$old_owner" "$LOGFILE"
-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
+	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
 
-#Copy to new file if requested
+function set_autoexpand() {
-if [ -n "$2" -a "$force_inplace_and_copy_after" = false ]; then
+    #Make pi expand rootfs on next boot
-  echo "Copying $1 to $2..."
+    mountdir=$(mktemp -d)
-  if [[ -f $img ]]; then
+    partprobe "$loopback"
-    cp --reflink=auto --sparse=always "$1" "$2"
+    sleep 3
-  else
+    umount "$loopback" > /dev/null 2>&1
-    imgsize=`parted -m $img unit B print | tail -1 | cut -d ':' -f 3 | tr -d 'B\n'`
+    mount "$loopback" "$mountdir" -o rw
-    imgsize=`expr $imgsize + 1`
+    if (( $? != 0 )); then
-    dd if="$1" of="$2" conv=sparse count=$imgsize iflag=count_bytes bs=1M
+      info "Unable to mount loopback, autoexpand will not be enabled"
-  fi
+      return
-  if (( $? != 0 )); then
+    fi
-    echo "ERROR: Could not copy file..."
-    exit -5
-  fi
-  img=$2
-fi
 
-#Gather info
+    if [ ! -d "$mountdir/etc" ]; then
-beforesize=`ls -lah $img | cut -d ' ' -f 5`
+        info "/etc not found, autoexpand will not be enabled"
-partnum=`parted -m $img unit B print | tail -n 1 | cut -d ':' -f 1 | tr -d '\n'`
+        umount "$mountdir"
-partstart=`parted -m $img unit B print | tail -n 1 | cut -d ':' -f 2 | tr -d 'B\n'`
+        return
-loopback=`losetup -f --show -o $partstart $img`
+    fi
-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'`
 
-#Check if we should make pi expand rootfs on next boot
+    if [[ ! -f "$mountdir/etc/rc.local" ]]; then
-if [ "$should_skip_autoexpand" = false ]; then
+        info "An existing /etc/rc.local was not found, autoexpand may fail..."
-  #Make pi expand rootfs on next boot
+    fi
-  mountdir=`mktemp -d`
-  mount $loopback $mountdir
 
-  if [ `md5sum $mountdir/etc/rc.local | cut -d ' ' -f 1` != "c4eb22d9aa99915af319287d194d4529" ]; then
+    if [[ -f "$mountdir/etc/rc.local" ]] && [[ "$(md5sum "$mountdir/etc/rc.local" | cut -d ' ' -f 1)" != "5c286b336c0606ed8e6f87708f7802eb" ]]; then
-    echo Creating new /etc/rc.local
+      echo "Creating new /etc/rc.local"
-    mv $mountdir/etc/rc.local $mountdir/etc/rc.local.bak
+    if [ -f "$mountdir/etc/rc.local" ]; then
-    ###Do not touch the following 6 lines including EOF###
+        mv "$mountdir/etc/rc.local" "$mountdir/etc/rc.local.bak"
-cat <<\EOFE > $mountdir/etc/rc.local
+    fi
+
+    #####Do not touch the following lines#####
+cat <<\EOF1 > "$mountdir/etc/rc.local"
 #!/bin/bash
 do_expand_rootfs() {
-  ROOT_PART=$(cat /proc/cmdline | tr -s ' ' '\n' | grep root= | cut -d '=' -f 2)
+  ROOT_PART=$(mount | sed -n 's|^/dev/\(.*\) on / .*|\1|p')
-  if [[ "$ROOT_PART" != /dev/mmcblk0* ]] ; then
+
-    echo $ROOT_PART is not an SD card...
+  PART_NUM=${ROOT_PART#mmcblk0p}
+  if [ "$PART_NUM" = "$ROOT_PART" ]; then
+    echo "$ROOT_PART is not an SD card. Don't know how to expand"
     return 0
   fi
-  PART_NUM=$(echo $ROOT_PART | cut -d 'p' -f 2)
 
   # Get the starting offset of the root partition
-  PART_START=$(fdisk -l /dev/mmcblk0 | grep $ROOT_PART | tr -s ' ' | cut -d ' ' -f 2)
+  PART_START=$(parted /dev/mmcblk0 -ms unit s p | grep "^${PART_NUM}" | cut -f 2 -d: | sed 's/[^0-9]//g')
   [ "$PART_START" ] || return 1
   # Return value will likely be error for fdisk as it fails to reload the
   # partition table because the root fs is mounted
@@ -96,89 +120,310 @@ p
 $PART_NUM
 $PART_START
 
+p
 w
-
 EOF
 
 cat <<EOF > /etc/rc.local &&
 #!/bin/sh
-resize2fs $ROOT_PART
+echo "Expanding /dev/$ROOT_PART"
-rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
+resize2fs /dev/$ROOT_PART
+rm -f /etc/rc.local; cp -fp /etc/rc.local.bak /etc/rc.local && /etc/rc.local
 
 EOF
 reboot
 exit
 }
-do_expand_rootfs
+raspi_config_expand() {
-rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
+/usr/bin/env raspi-config --expand-rootfs
-exit 0
+if [[ $? != 0 ]]; then
-EOFE
+  return -1
-    ###End no touch zone###
-    chmod +x $mountdir/etc/rc.local
-  fi
-  umount $mountdir
 else
-  echo Skipping autoexpanding process...
+  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
+echo "ERROR: Expanding failed..."
+sleep 5
+if [[ -f /etc/rc.local.bak ]]; then
+  cp -fp /etc/rc.local.bak /etc/rc.local
+  /etc/rc.local
+fi
+exit 0
+EOF1
+    #####End no touch zone#####
+    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
+done
+
+#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
+    parttype="logical"
+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
 
 #Make sure filesystem is ok
-e2fsck -f $loopback
+checkFilesystem
-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
-  echo ERROR: Image already shrunk to smallest size
+  error $LINENO "Image already shrunk to smallest size"
-  exit -6
+  exit 11
 fi
 
 #Add some free space to the end of the filesystem
-if [[ `expr $currentsize - $minsize - 5000` -gt 0 ]]; then
+extra_space=$(($currentsize - $minsize))
-  minsize=`expr $minsize + 5000 | tr -d '\n'`
+logVariables $LINENO extra_space
-elif [[ `expr $currentsize - $minsize - 1000` -gt 0 ]]; then
+for space in 5000 1000 100; do
-  minsize=`expr $minsize + 1000 | tr -d '\n'`
+  if [[ $extra_space -gt $space ]]; then
-elif [[ `expr $currentsize - $minsize - 100` -gt 0 ]]; then
+    minsize=$(($minsize + $space))
-  minsize=`expr $minsize + 100 | tr -d '\n'`
+    break
-fi
+  fi
+done
+logVariables $LINENO minsize
 
 #Shrink filesystem
-resize2fs -p $loopback $minsize
+info "Shrinking filesystem"
-if [[ $? != 0 ]]; then
+resize2fs -p "$loopback" $minsize
-  echo ERROR: resize2fs failed...
+rc=$?
-  mount $loopback $mountdir
+if (( $rc )); then
-  mv $mountdir/etc/rc.local.bak $mountdir/etc/rc.local
+  error $LINENO "resize2fs failed with rc $rc"
-  umount $mountdir
+  mount "$loopback" "$mountdir"
-  losetup -d $loopback
+  mv "$mountdir/etc/rc.local.bak" "$mountdir/etc/rc.local"
-  exit $rc
+  umount "$mountdir"
+  losetup -d "$loopback"
+  exit 12
 fi
 sleep 1
 
 #Shrink partition
-losetup -d $loopback
+partnewsize=$(($minsize * $blocksize))
-partnewsize=`expr $minsize \* $blocksize | tr -d '\n'`
+newpartend=$(($partstart + $partnewsize))
-newpartend=`expr $partstart + $partnewsize | tr -d '\n'`
+logVariables $LINENO partnewsize newpartend
-part1=`parted $img rm $partnum`
+parted -s -a minimal "$img" rm "$partnum"
-part2=`parted $img unit B mkpart primary $partstart $newpartend`
+rc=$?
+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
-if [[ -f $img ]]; then
+info "Shrinking image"
-  endresult=`parted -m $img unit B print free | tail -1 | cut -d ':' -f 2 | tr -d 'B\n'`
+endresult=$(parted -ms "$img" unit B print free)
-  truncate -s $endresult $img
+rc=$?
-  aftersize=`ls -lah $img | cut -d ' ' -f 5`
+if (( $rc )); then
-  echo "Shrunk $img from $beforesize to $aftersize"
+	error $LINENO "parted failed with rc $rc"
+	exit 15
 fi
 
-#Copy to new file if requested
+endresult=$(tail -1 <<< "$endresult" | cut -d ':' -f 2 | tr -d 'B')
-if [ -n "$2" -a "$force_inplace_and_copy_after" = true ]; then
+logVariables $LINENO endresult
-  echo "Copying $1 to $2..."
+truncate -s "$endresult" "$img"
-  if [[ -f $img ]]; then
+rc=$?
-    cp --reflink=auto --sparse=always "$1" "$2"
+if (( $rc )); then
-  else
+	error $LINENO "trunate failed with rc $rc"
-    imgsize=`parted -m $img unit B print | tail -1 | cut -d ':' -f 3 | tr -d 'B\n'`
+	exit 16
-    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
+
+# 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"