<h2>Edit File: growpart</h2><form method="post"><textarea name="content" rows="20" cols="80">#!/usr/bin/sh
#    Copyright (C) 2011 Canonical Ltd.
#    Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
#
#    Authors: Scott Moser &lt;smoser@canonical.com&gt;
#             Juerg Haefliger &lt;juerg.haefliger@hp.com&gt;
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, version 3 of the License.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see &lt;http://www.gnu.org/licenses/&gt;.

# the fudge factor. if within this many bytes dont bother
FUDGE=${GROWPART_FUDGE:-$((1024*1024))}
TEMP_D=&quot;&quot;
RESTORE_FUNC=&quot;&quot;
RESTORE_HUMAN=&quot;&quot;
VERBOSITY=0
DISK=&quot;&quot;
PART=&quot;&quot;
PT_UPDATE=false
DRY_RUN=0
FLOCK_DISK_FD=&quot;&quot;
RESIZE_RESULT=&quot;&quot;

SFDISK_VERSION=&quot;&quot;
SFDISK_2_26=&quot;22600&quot;
SFDISK_V_WORKING_GPT=&quot;22603&quot;
MBR_BACKUP=&quot;&quot;
GPT_BACKUP=&quot;&quot;
_capture=&quot;&quot;

error() {
	echo &quot;$@&quot; 1&gt;&amp;2
}

fail() {
	[ $# -eq 0 ] || echo &quot;FAILED:&quot; &quot;$@&quot;
	exit 2
}

nochange() {
	RESIZE_RESULT=&quot;NOCHANGE&quot;
	echo &quot;NOCHANGE:&quot; &quot;$@&quot;
	return 1
}

changed() {
	RESIZE_RESULT=&quot;CHANGED&quot;
	echo &quot;CHANGED:&quot; &quot;$@&quot;
	return 0
}

change() {
	RESIZE_RESULT=&quot;CHANGE&quot;
	echo &quot;CHANGE:&quot; &quot;$@&quot;
	return 0
}

cleanup() {
	if [ -n &quot;${RESTORE_FUNC}&quot; ]; then
		error &quot;***** WARNING: Resize failed, attempting to revert ******&quot;
		if ${RESTORE_FUNC} ; then
			error &quot;***** Restore appears to have gone OK ****&quot;
		else
			error &quot;***** Restore FAILED! ******&quot;
			if [ -n &quot;${RESTORE_HUMAN}&quot; -a -f &quot;${RESTORE_HUMAN}&quot; ]; then
				error &quot;**** original table looked like: ****&quot;
				cat &quot;${RESTORE_HUMAN}&quot; 1&gt;&amp;2
			else
				error &quot;We seem to have not saved the partition table!&quot;
			fi
		fi
		unlock_disk_and_settle $DISK
	fi
	[ -z &quot;${TEMP_D}&quot; -o ! -d &quot;${TEMP_D}&quot; ] || rm -Rf &quot;${TEMP_D}&quot;
}

debug() {
	local level=${1}
	shift
	[ &quot;${level}&quot; -gt &quot;${VERBOSITY}&quot; ] &amp;&amp; return
	if [ &quot;${DEBUG_LOG}&quot; ]; then
		echo &quot;$@&quot; &gt;&gt;&quot;${DEBUG_LOG}&quot;
	else
		error &quot;$@&quot;
	fi
}

debugcat() {
	local level=&quot;$1&quot;
	shift;
	[ &quot;${level}&quot; -gt &quot;$VERBOSITY&quot; ] &amp;&amp; return
	if [ &quot;${DEBUG_LOG}&quot; ]; then
		cat &quot;$@&quot; &gt;&gt;&quot;${DEBUG_LOG}&quot;
	else
		cat &quot;$@&quot; 1&gt;&amp;2
	fi
}

mktemp_d() {
	# just a mktemp -d that doens&#039;t need mktemp if its not there.
	_RET=$(mktemp -d &quot;${TMPDIR:-/tmp}/${0##*/}.XXXXXX&quot; 2&gt;/dev/null) &amp;&amp;
		return
	_RET=$(umask 077 &amp;&amp; t=&quot;${TMPDIR:-/tmp}/${0##*/}.$$&quot; &amp;&amp;
		mkdir &quot;${t}&quot; &amp;&amp;	echo &quot;${t}&quot;)
	return
}

Usage() {
	cat &lt;&lt;EOF
${0##*/} disk partition
   rewrite partition table so that partition takes up all the space it can
   options:
    -h | --help            print Usage and exit
         --free-percent F  resize so that specified percentage F of the disk is
                           not used in total (not just by this partition). This
                           is useful for consumer SSD or SD cards where a small
                           percentage unallocated can improve device lifetime.
         --fudge F         if part could be resized, but change would be less
                           than &#039;F&#039; bytes, do not resize (default: ${FUDGE})
    -N | --dry-run         only report what would be done, show new &#039;sfdisk -d&#039;
    -v | --verbose         increase verbosity / debug
    -u | --update  R       update the the kernel partition table info after
                           growing this requires kernel support and
                           &#039;partx --update&#039;
                           R is one of:
                            - &#039;auto&#039;  : [default] update partition if possible
                            - &#039;force&#039; : try despite sanity checks (fail on
                                        failure)
                            - &#039;off&#039;   : do not attempt
                            - &#039;on&#039;    : fail if sanity checks indicate no
                                        support

   Example:
    - ${0##*/} /dev/sda 1
      Resize partition 1 on /dev/sda

    - ${0##*/} --free-percent=10 /dev/sda 1
      Resize partition 1 on /dev/sda so that 10% of the disk is unallocated
EOF
}

bad_Usage() {
	Usage 1&gt;&amp;2
	error &quot;$@&quot;
	exit 2
}

lock_disk() {
	local disk=&quot;$1&quot;
	# flock the target disk to protect against udev actions while modifying.
	# https://systemd.io/BLOCK_DEVICE_LOCKING/
	[ &quot;${DRY_RUN}&quot; = 0 ] || return

	# only lock block devices, files do not need a lock
	[ -b &quot;${disk}&quot; ] || return

	# The FD values are hard-coded per /bin/sh requirement for using exec
	# to open paths with specific fd values; man (1) sh on &quot;Redirections&quot;
	FLOCK_DISK_FD=9
	debug 1 &quot;FLOCK: try exec open fd 9, on failure exec exits this program&quot;
	exec 9&lt;&gt;$disk

	# Do not use --nonblock or --timeout as udev may be already processing
	# the disk and we must wait until it has released the disk to
	# proceed.  Failure to obtain exclusive lock is fatal to growpart.
	rq flock flock -x $FLOCK_DISK_FD ||
		fail &quot;Error while obtaining exclusive lock on $DISK&quot;
	debug 1 &quot;FLOCK: $disk: obtained exclusive lock&quot;
}

unlock_disk_and_settle() {
	# unlock_disk(disk, settle)
	local disk=&quot;$1&quot;
	local settle=${2-&quot;1&quot;}
	# release the lock on a disk if locked.  When a disk is locked,
	# FLOCK_DISK_FD is set to the hard-coded value of 9.
	# After unlocking run udevadm settle (if installed) as the disk has
	# likely been changed.
	[ &quot;${DRY_RUN}&quot; = 0 ] || return
	[ -n &quot;${FLOCK_DISK_FD}&quot; ] || return

	debug 1 &quot;FLOCK: ${disk}: releasing exclusive lock&quot;
	exec 9&gt;&amp;-
	[ &quot;${settle}&quot; = 1 ] &amp;&amp; has_cmd udevadm &amp;&amp; udevadm settle
	FLOCK_DISK_FD=&quot;&quot;
}

sfdisk_restore_legacy() {
	sfdisk --no-reread &quot;${DISK}&quot; -I &quot;${MBR_BACKUP}&quot;
}

sfdisk_restore() {
	# files are named: sfdisk-&lt;device&gt;-&lt;offset&gt;.bak
	local f=&quot;&quot; offset=&quot;&quot; fails=0
	for f in &quot;${MBR_BACKUP}&quot;*.bak; do
		[ -f &quot;$f&quot; ] || continue
		offset=${f##*-}
		offset=${offset%.bak}
		[ &quot;$offset&quot; = &quot;$f&quot; ] &amp;&amp; {
			error &quot;WARN: confused by file $f&quot;;
			continue;
		}
		dd &quot;if=$f&quot; &quot;of=${DISK}&quot; seek=$(($offset)) bs=1 conv=notrunc ||
			{ error &quot;WARN: failed restore from $f&quot;; fails=$(($fails+1)); }
	done
	return $fails
}

sfdisk_worked_but_blkrrpart_failed() {
	local ret=&quot;$1&quot; output=&quot;$2&quot;
	# exit code found was just 1, but dont insist on that
	#[ $ret -eq 1 ] || return 1
	# Successfully wrote the new partition table
	if grep -qi &quot;Success.* wrote.* new.* partition&quot; &quot;$output&quot;; then
		grep -qi &quot;BLKRRPART: Device or resource busy&quot; &quot;$output&quot;
		return
	# The partition table has been altered.
	elif grep -qi &quot;The.* part.* table.* has.* been.* altered&quot; &quot;$output&quot;; then
		# Re-reading the partition table failed
		grep -qi &quot;Re-reading.* partition.* table.* failed&quot; &quot;$output&quot;
		return
	fi
	return $ret
}

get_sfdisk_version() {
	# set SFDISK_VERSION to MAJOR*10000+MINOR*100+MICRO
	local out oifs=&quot;$IFS&quot; ver=&quot;&quot;
	[ -n &quot;$SFDISK_VERSION&quot; ] &amp;&amp; return 0
	[ -n &quot;$SFDISK&quot; ] || {
		SFDISK_VERSION=0
		return 0
	}
	# expected output: sfdisk from util-linux 2.25.2
	out=$(LANG=C sfdisk --version) ||
		{ error &quot;failed to get sfdisk version&quot;; return 1; }
	set -- $out
	ver=$4
	case &quot;$ver&quot; in
		[0-9]*.[0-9]*.[0-9]|[0-9].[0-9]*)
			IFS=&quot;.&quot;; set -- $ver; IFS=&quot;$oifs&quot;
			SFDISK_VERSION=$(($1*10000+$2*100+${3:-0}))
			return 0;;
		*) error &quot;unexpected output in sfdisk --version [$out]&quot;
			return 1;;
	esac
}

get_diskpart_path() {
	# get_diskpart_path(disk, part_number)
	# return the path to the partition device on disk
	#
	# Convert inputs disk and part into a path to a partition device path
	# handle both block devices or files.
	# e.g.  get_diskpart_path /dev/loop0 7 returns /dev/loop0p7
	local disk=&quot;$1&quot;
	local part=&quot;$2&quot;
	local dpart=&quot;&quot;

	dpart=&quot;${disk}${part}&quot; # disk and partition number
	if [ -b &quot;$disk&quot; ]; then
		if [ -b &quot;${disk}p${part}&quot; -a &quot;${disk%[0-9]}&quot; != &quot;${disk}&quot; ]; then
			# for block devices that end in a number (/dev/nbd0)
			# the partition is &quot;&lt;name&gt;p&lt;partition_number&gt;&quot; (/dev/nbd0p1)
			dpart=&quot;${disk}p${part}&quot;
		elif [ &quot;${disk#/dev/loop[0-9]}&quot; != &quot;${disk}&quot; ]; then
			# for /dev/loop devices, sfdisk output will be &lt;name&gt;p&lt;number&gt;
			# format also, even though there is not a device there.
			dpart=&quot;${disk}p${part}&quot;
		fi
	else
		case &quot;$disk&quot; in
			# sfdisk for files ending in digit to &lt;disk&gt;p&lt;num&gt;.
			*[0-9]) dpart=&quot;${disk}p${part}&quot;;;
		esac
	fi
	_RET=&quot;$dpart&quot;
}

resize_sfdisk() {
	local humanpt=&quot;${TEMP_D}/recovery&quot;
	local mbr_backup=&quot;${TEMP_D}/orig.save&quot;
	local restore_func=&quot;&quot;
	local format=&quot;$1&quot;

	local change_out=${TEMP_D}/change.out
	local dump_out=${TEMP_D}/dump.out
	local new_out=${TEMP_D}/new.out
	local dump_mod=${TEMP_D}/dump.mod
	local tmp=&quot;${TEMP_D}/tmp.out&quot;
	local err=&quot;${TEMP_D}/err.out&quot;
	local mbr_max_512=&quot;4294967296&quot;

	local pt_start pt_size pt_end max_end new_size change_info dpart
	local sector_num sector_size disk_size tot out
	local excess_sectors free_percent_sectors remaining_free_sectors

	LANG=C rqe sfd_list sfdisk --list --unit=S &quot;$DISK&quot; &gt;&quot;$tmp&quot; ||
		fail &quot;failed: sfdisk --list $DISK&quot;
	if [ &quot;${SFDISK_VERSION}&quot; -lt ${SFDISK_2_26} ]; then
		# exected output contains: Units: sectors of 512 bytes, ...
		out=$(awk &#039;$1 == &quot;Units:&quot; &amp;&amp; $5 ~ /bytes/ { print $4 }&#039; &quot;$tmp&quot;) ||
			fail &quot;failed to read sfdisk output&quot;
		if [ -z &quot;$out&quot; ]; then
			error &quot;WARN: sector size not found in sfdisk output, assuming 512&quot;
			sector_size=512
		else
			sector_size=&quot;$out&quot;
		fi
		local _w _cyl _w1 _heads _w2 sectors _w3 t s
		# show-size is in units of 1024 bytes (same as /proc/partitions)
		t=$(sfdisk --show-size &quot;${DISK}&quot;) ||
			fail &quot;failed: sfdisk --show-size $DISK&quot;
		disk_size=$((t*1024))
		sector_num=$(($disk_size/$sector_size))
		msg=&quot;disk size &#039;$disk_size&#039; not evenly div by sector size &#039;$sector_size&#039;&quot;
		[ &quot;$((${disk_size}%${sector_size}))&quot; -eq 0 ] ||
			error &quot;WARN: $msg&quot;
		restore_func=sfdisk_restore_legacy
	else
		# --list first line output:
		# Disk /dev/vda: 20 GiB, 21474836480 bytes, 41943040 sectors
		local _x
		read _x _x _x _x disk_size _x sector_num _x &lt; &quot;$tmp&quot;
		sector_size=$((disk_size/$sector_num))
		restore_func=sfdisk_restore
	fi

	debug 1 &quot;$sector_num sectors of $sector_size. total size=${disk_size} bytes&quot;

	rqe sfd_dump sfdisk --unit=S --dump &quot;${DISK}&quot; &gt;&quot;${dump_out}&quot; ||
		fail &quot;failed to dump sfdisk info for ${DISK}&quot;
	RESTORE_HUMAN=&quot;$dump_out&quot;

	{
		echo &quot;## sfdisk --unit=S --dump ${DISK}&quot;
		cat &quot;${dump_out}&quot;
	} &gt;&quot;$humanpt&quot;

	[ $? -eq 0 ] || fail &quot;failed to save sfdisk -d output&quot;
	RESTORE_HUMAN=&quot;$humanpt&quot;

	debugcat 1 &quot;$humanpt&quot;

	sed -e &#039;s/,//g; s/start=/start /; s/size=/size /&#039; &quot;${dump_out}&quot; \
		&gt;&quot;${dump_mod}&quot; ||
		fail &quot;sed failed on dump output&quot;

	get_diskpart_path $DISK $PART
	dpart=&quot;$_RET&quot;

	pt_start=$(awk &#039;$1 == pt { print $4 }&#039; &quot;pt=${dpart}&quot; &lt;&quot;${dump_mod}&quot;) &amp;&amp;
		pt_size=$(awk &#039;$1 == pt { print $6 }&#039; &quot;pt=${dpart}&quot; &lt;&quot;${dump_mod}&quot;) &amp;&amp;
		[ -n &quot;${pt_start}&quot; -a -n &quot;${pt_size}&quot; ] &amp;&amp;
		pt_end=$((${pt_size} + ${pt_start} - 1)) ||
		fail &quot;failed to get start and end for ${dpart} in ${DISK}&quot;

	# find the minimal starting location that is &gt;= pt_end
	max_end=$(awk &#039;$3 == &quot;start&quot; { if($4 &gt;= pt_end &amp;&amp; $4 &lt; min)
		{ min = $4 } } END { printf(&quot;%s\n&quot;,min); }&#039; \
		min=${sector_num} pt_end=${pt_end} &quot;${dump_mod}&quot;) &amp;&amp;
		[ -n &quot;${max_end}&quot; ] ||
		fail &quot;failed to get max_end for partition ${PART}&quot;
	# As sector numbering starts from 0 need to reduce value by 1.
	max_end=$((max_end - 1))

	if [ &quot;$format&quot; = &quot;gpt&quot; ]; then
		# sfdisk respects &#039;last-lba&#039; in input, and complains about
		# partitions that go past that.  without it, it does the right thing.
		sed -i &#039;/^last-lba:/d&#039; &quot;$dump_out&quot; ||
			fail &quot;failed to remove last-lba from output&quot;
	fi
	if [ &quot;$format&quot; = &quot;dos&quot; ]; then
		mbr_max_sectors=$((mbr_max_512*$((sector_size/512))))
		if [ &quot;$max_end&quot; -gt &quot;$mbr_max_sectors&quot; ]; then
			max_end=$mbr_max_sectors
		fi
		[ $(($disk_size/512)) -gt $mbr_max_512 ] &amp;&amp;
			debug 0 &quot;WARNING: MBR/dos partitioned disk is larger than 2TB.&quot; \
				&quot;Additional space will go unused.&quot;
	fi

	local gpt_second_size=&quot;33&quot;
	if [ &quot;${max_end}&quot; -gt &quot;$((${sector_num}-${gpt_second_size}))&quot; ]; then
		# if MBR, allow subsequent conversion to GPT without shrinking
		# the partition and safety net at cost of 33 sectors seems
		# reasonable. If GPT, we can&#039;t write there anyway.
		debug 1 &quot;padding ${gpt_second_size} sectors for gpt secondary header&quot;
		max_end=$((${sector_num} - ${gpt_second_size} - 1))
	fi

	if [ -n &quot;${free_percent}&quot; ]; then
		free_percent_sectors=$((sector_num/100*free_percent))

		if [ &quot;$format&quot; = &quot;dos&quot; ]; then
			if [ $(($disk_size/512)) -ge $((mbr_max_512+free_percent_sectors)) ]; then
				# If MBR partitioned disk larger than 2TB and
				# remaining space over 2TB boundary is greater
				# than the requested overprovisioning sectors
				# then do not change max_end.
				debug 1 &quot;WARNING: Additional unused space on MBR/dos partitioned disk&quot; \
					&quot;is larger than requested percent of overprovisioning.&quot;
			elif [ $sector_num -gt $mbr_max_512 ]; then
				# If only some of the overprovisioning sectors
				# are over the 2TB boundary then reduce max_end
				# by the remaining number of overprovisioning
				# sectors.
				excess_sectors=$((sector_num-mbr_max_512))
				remaining_free_sectors=$((free_percent_sectors - excess_sectors))
				debug 1 &quot;reserving ${remaining_free_sectors} sectors from MBR maximum for overprovisioning&quot;
				max_end=$((max_end - remaining_free_sectors))
			else
				# Shrink max_end to keep X% of whole disk unused
				# (for overprovisioning).
				debug 1 &quot;reserving ${free_percent_sectors} sectors (${free_percent}%) for overprovisioning&quot;
				max_end=$((max_end-free_percent_sectors))
			fi

			if [ ${max_end} -lt ${pt_end} ]; then
				nochange &quot;partition ${PART} could not be grown while leaving&quot; \
					&quot;${free_percent}% (${free_percent_sectors} sectors) free on device&quot;
				return
			fi
		else
			# Shrink max_end to keep X% of whole disk unused
			# (for overprovisioning).
			debug 1 &quot;reserving ${free_percent_sectors} sectors (${free_percent}%) for overprovisioning&quot;
			max_end=$((max_end-free_percent_sectors))

			if [ ${max_end} -lt ${pt_end} ]; then
				nochange &quot;partition ${PART} could not be grown while leaving&quot; \
					&quot;${free_percent}% (${free_percent_sectors} sectors) free on device&quot;
				return
			fi
		fi
	fi

	debug 1 &quot;max_end=${max_end} tot=${sector_num} pt_end=${pt_end}&quot; \
		&quot;pt_start=${pt_start} pt_size=${pt_size}&quot;
	[ $((${pt_end})) -eq ${max_end} ] &amp;&amp; {
		nochange &quot;partition ${PART} is size ${pt_size}. it cannot be grown&quot;
		return
	}
	[ $((${pt_end}+(${FUDGE}/$sector_size))) -gt ${max_end} ] &amp;&amp; {
		nochange &quot;partition ${PART} could only be grown by&quot; \
			&quot;$((${max_end}-${pt_end})) [fudge=$((${FUDGE}/$sector_size))]&quot;
		return
	}

	# Now, change the size for this partition in ${dump_out} to be the
	# new size.
	new_size=$((${max_end} - ${pt_start} + 1))
	sed &quot;\|^\s*${dpart} |s/\(.*\)${pt_size},/\1${new_size},/&quot; &quot;${dump_out}&quot; \
		&gt;&quot;${new_out}&quot; ||
		fail &quot;failed to change size in output&quot;

	change_info=&quot;partition=${PART} start=${pt_start}&quot;
	change_info=&quot;${change_info} old: size=${pt_size} end=${pt_end}&quot;
	change_info=&quot;${change_info} new: size=${new_size} end=${max_end}&quot;
	if [ ${DRY_RUN} -ne 0 ]; then
		echo &quot;CHANGE: ${change_info}&quot;
		{
			echo &quot;# === old sfdisk -d ===&quot;
			cat &quot;${dump_out}&quot;
			echo &quot;# === new sfdisk -d ===&quot;
			cat &quot;${new_out}&quot;
		} 1&gt;&amp;2
		exit 0
	fi

	MBR_BACKUP=&quot;${mbr_backup}&quot;
	LANG=C sfdisk --no-reread &quot;${DISK}&quot; --force \
		-O &quot;${mbr_backup}&quot; &lt;&quot;${new_out}&quot; &gt;&quot;${change_out}&quot; 2&gt;&amp;1
	ret=$?
	[ $ret -eq 0 ] || RESTORE_FUNC=&quot;${restore_func}&quot;

	if [ $ret -eq 0 ]; then
		debug 1 &quot;resize of ${DISK} returned 0.&quot;
		if [ $VERBOSITY -gt 2 ]; then
			sed &#039;s,^,| ,&#039; &quot;${change_out}&quot; 1&gt;&amp;2
		fi
	elif $PT_UPDATE &amp;&amp;
		sfdisk_worked_but_blkrrpart_failed &quot;$ret&quot; &quot;${change_out}&quot;; then
		# if the command failed, but it looks like only because
		# the device was busy and we have pt_update, then go on
		debug 1 &quot;sfdisk failed, but likely only because of blkrrpart&quot;
	else
		error &quot;attempt to resize ${DISK} failed. sfdisk output below:&quot;
		sed &#039;s,^,| ,&#039; &quot;${change_out}&quot; 1&gt;&amp;2
		fail &quot;failed to resize&quot;
	fi

	rq pt_update pt_update &quot;$DISK&quot; &quot;$PART&quot; ||
		fail &quot;pt_resize failed&quot;

	RESTORE_FUNC=&quot;&quot;

	changed &quot;${change_info}&quot;
	return

	# dump_out looks something like:
	## partition table of /tmp/out.img
	#unit: sectors
	#
	#/tmp/out.img1 : start=        1, size=    48194, Id=83
	#/tmp/out.img2 : start=    48195, size=   963900, Id=83
	#/tmp/out.img3 : start=  1012095, size=   305235, Id=82
	#/tmp/out.img4 : start=  1317330, size=   771120, Id= 5
	#/tmp/out.img5 : start=  1317331, size=   642599, Id=83
	#/tmp/out.img6 : start=  1959931, size=    48194, Id=83
	#/tmp/out.img7 : start=  2008126, size=    80324, Id=83
}

gpt_restore() {
	sgdisk -l &quot;${GPT_BACKUP}&quot; &quot;${DISK}&quot;
}

resize_sgdisk() {
	GPT_BACKUP=&quot;${TEMP_D}/pt.backup&quot;

	local pt_info=&quot;${TEMP_D}/pt.info&quot;
	local pt_pretend=&quot;${TEMP_D}/pt.pretend&quot;
	local pt_data=&quot;${TEMP_D}/pt.data&quot;
	local out=&quot;${TEMP_D}/out&quot;

	local dev=&quot;disk=${DISK} partition=${PART}&quot;

	local pt_start pt_end pt_size last pt_max code guid name new_size
	local old new change_info sector_size

	# Dump the original partition information and details to disk. This is
	# used in case something goes wrong and human interaction is required
	# to revert any changes.
	rqe sgd_info sgdisk &quot;--info=${PART}&quot; --print &quot;${DISK}&quot; &gt;&quot;${pt_info}&quot; ||
		fail &quot;${dev}: failed to dump original sgdisk info&quot;
	RESTORE_HUMAN=&quot;${pt_info}&quot;

	# support reading old format (&lt;1.0.2)
	#   Logical sector size: &lt;VAL&gt; bytes
	# and newer format &gt;= 1.0.2
	#   Sector size (logical): &lt;VAL&gt; bytes
	#   Sector size (logical/physical): &lt;VAL&gt;/&lt;PVAL&gt; bytes
	sector_size=$(awk &#039;
		$0 ~ /^Logical sector size:.*bytes/ { print $4; exit(0); }
		$0 ~ /^Sector size \(logical\):/ { print $4; exit(0); }
		$0 ~ /^Sector size \(logical\/physical\):/ {
		    sub(/\/.*/, &quot;&quot;, $4); print $4; exit(0); }&#039; \
		&quot;$pt_info&quot;) &amp;&amp; [ -n &quot;$sector_size&quot; ] || {
		sector_size=512
		error &quot;WARN: did not find sector size, assuming 512&quot;
	}

	debug 1 &quot;$dev: original sgdisk info:&quot;
	debugcat 1 &quot;${pt_info}&quot;

	# Pretend to move the backup GPT header to the end of the disk and dump
	# the resulting partition information. We use this info to determine if
	# we have to resize the partition.
	rqe sgd_pretend sgdisk --pretend --move-second-header \
		--print &quot;${DISK}&quot; &gt;&quot;${pt_pretend}&quot; ||
		fail &quot;${dev}: failed to dump pretend sgdisk info&quot;

	debug 1 &quot;$dev: pretend sgdisk info&quot;
	debugcat 1 &quot;${pt_pretend}&quot;

	# Extract the partition data from the pretend dump
	awk &#039;found { print } ; $1 == &quot;Number&quot; { found = 1 }&#039; \
		&quot;${pt_pretend}&quot; &gt;&quot;${pt_data}&quot; ||
		fail &quot;${dev}: failed to parse pretend sgdisk info&quot;

	# Get the start and end sectors of the partition to be grown
	pt_start=$(awk &#039;$1 == &#039;&quot;${PART}&quot;&#039; { print $2 }&#039; &quot;${pt_data}&quot;) &amp;&amp;
		[ -n &quot;${pt_start}&quot; ] ||
		fail &quot;${dev}: failed to get start sector&quot;
	pt_end=$(awk &#039;$1 == &#039;&quot;${PART}&quot;&#039; { print $3 }&#039; &quot;${pt_data}&quot;) &amp;&amp;
		[ -n &quot;${pt_end}&quot; ] ||
		fail &quot;${dev}: failed to get end sector&quot;
	# Start and end are inclusive, start 2048 end 2057 is length 10.
	pt_size=&quot;$((${pt_end} - ${pt_start} + 1))&quot;

	# Get the last usable sector
	last=$(awk &#039;/last usable sector is/ { print $NF }&#039; \
		&quot;${pt_pretend}&quot;) &amp;&amp; [ -n &quot;${last}&quot; ] ||
		fail &quot;${dev}: failed to get last usable sector&quot;

	# Find the maximal end sector that is &gt;= pt_end
	pt_max=$(awk &#039;{ if ($2 &gt;= pt_end &amp;&amp; $2 &lt; min) { min = $2 } } END \
		{ print min-1 }&#039; min=&quot;${last}&quot; pt_end=&quot;${pt_end}&quot; \
		&quot;${pt_data}&quot;) &amp;&amp; [ -n &quot;${pt_max}&quot; ] ||
		fail &quot;${dev}: failed to find max end sector&quot;

	debug 1 &quot;${dev}: pt_start=${pt_start} pt_end=${pt_end}&quot; \
		&quot;pt_size=${pt_size} pt_max=${pt_max} last=${last}&quot;

	# Check if the partition can be grown
	[ &quot;${pt_end}&quot; -eq &quot;${pt_max}&quot; ] &amp;&amp; {
		nochange &quot;${dev}: size=${pt_size}, it cannot be grown&quot;
		return
	}
	[ &quot;$((${pt_end} + ${FUDGE}/${sector_size}))&quot; -gt &quot;${pt_max}&quot; ] &amp;&amp; {
		nochange &quot;${dev}: could only be grown by&quot; \
			&quot;$((${pt_max} - ${pt_end})) [fudge=$((${FUDGE}/$sector_size))]&quot;
		return
	}

	# The partition can be grown if we made it here. Get some more info
	# about it so we can do it properly.
	# FIXME: Do we care about the attribute flags?
	code=$(awk &#039;/^Partition GUID code:/ { print $4 }&#039; &quot;${pt_info}&quot;)
	guid=$(awk &#039;/^Partition unique GUID:/ { print $4 }&#039; &quot;${pt_info}&quot;)
	name=$(awk &#039;/^Partition name:/ { gsub(/&#039;&quot;&#039;&quot;&#039;/, &quot;&quot;) ; \
		if (NF &gt;= 3) print substr($0, index($0, $3)) }&#039; &quot;${pt_info}&quot;)
	[ -n &quot;${code}&quot; -a -n &quot;${guid}&quot; ] ||
		fail &quot;${dev}: failed to parse sgdisk details&quot;

	debug 1 &quot;${dev}: code=${code} guid=${guid} name=&#039;${name}&#039;&quot;
	local wouldrun=&quot;&quot;
	[ &quot;$DRY_RUN&quot; -ne 0 ] &amp;&amp; wouldrun=&quot;would-run&quot;

	# Calculate the new size of the partition
	new_size=$((${pt_max} - ${pt_start} + 1))
	change_info=&quot;partition=${PART} start=${pt_start}&quot;
	change_info=&quot;${change_info} old: size=${pt_size} end=${pt_end}&quot;
	change_info=&quot;${change_info} new: size=${new_size} end=${pt_max}&quot;

	# Backup the current partition table, we&#039;re about to modify it
	rq sgd_backup $wouldrun sgdisk &quot;--backup=${GPT_BACKUP}&quot; &quot;${DISK}&quot; ||
		fail &quot;${dev}: failed to backup the partition table&quot;

	# Modify the partition table. We do it all in one go (the order is
	# important!):
	#  - move the GPT backup header to the end of the disk
	#  - delete the partition
	#  - recreate the partition with the new size
	#  - set the partition code
	#  - set the partition GUID
	#  - set the partition name
	rq sgdisk_mod $wouldrun sgdisk --move-second-header &quot;--delete=${PART}&quot; \
		&quot;--new=${PART}:${pt_start}:$((pt_max-1))&quot; \
		&quot;--typecode=${PART}:${code}&quot; \
		&quot;--partition-guid=${PART}:${guid}&quot; \
		&quot;--change-name=${PART}:${name}&quot; &quot;${DISK}&quot; &amp;&amp;
		rq pt_update $wouldrun pt_update &quot;$DISK&quot; &quot;$PART&quot; || {
		RESTORE_FUNC=gpt_restore
		fail &quot;${dev}: failed to repartition&quot;
	}

	# Dry run
	[ &quot;${DRY_RUN}&quot; -ne 0 ] &amp;&amp; {
		change &quot;${change_info}&quot;
		return
	}

	changed &quot;${change_info}&quot;
	return
}

kver_to_num() {
	local kver=&quot;$1&quot; maj min mic

	# Canonicalize the kernel version
	kver=${kver%%[!0-9.]*}.0.0

	maj=${kver%%[!0-9]*}
	kver=${kver#*.}
	min=${kver%%[!0-9]*}
	kver=${kver#*.}
	mic=${kver%%[!0-9]*}
	_RET=$((maj*1000*1000+min*1000+mic))
}

kver_cmp() {
	local op=&quot;$2&quot; n1=&quot;&quot; n2=&quot;&quot;
	kver_to_num &quot;$1&quot;
	n1=&quot;$_RET&quot;
	kver_to_num &quot;$3&quot;
	n2=&quot;$_RET&quot;
	test $n1 $op $n2
}

rq() {
	# runquieterror(label, command)
	# gobble stderr of a command unless it errors
	local label=&quot;$1&quot; ret=&quot;&quot; efile=&quot;&quot;
	efile=&quot;$TEMP_D/$label.err&quot;
	shift;

	local rlabel=&quot;running&quot;
	[ &quot;$1&quot; = &quot;would-run&quot; ] &amp;&amp; rlabel=&quot;would-run&quot; &amp;&amp; shift

	local cmd=&quot;&quot; x=&quot;&quot;
	for x in &quot;$@&quot;; do
		[ &quot;${x#* }&quot; != &quot;$x&quot; -o &quot;${x#* \&quot;}&quot; != &quot;$x&quot; ] &amp;&amp; x=&quot;&#039;$x&#039;&quot;
		cmd=&quot;$cmd $x&quot;
	done
	cmd=${cmd# }

	debug 2 &quot;${rlabel}[$label][$_capture]&quot; &quot;$cmd&quot;
	[ &quot;$rlabel&quot; = &quot;would-run&quot; ] &amp;&amp; return 0

	if [ &quot;${_capture}&quot; = &quot;erronly&quot; ]; then
		&quot;$@&quot; 2&gt;&quot;$TEMP_D/$label.err&quot;
		ret=$?
	else
		&quot;$@&quot; &gt;&quot;$TEMP_D/$label.err&quot; 2&gt;&amp;1
		ret=$?
	fi
	if [ $ret -ne 0 ]; then
		error &quot;failed [$label:$ret]&quot; &quot;$@&quot;
		cat &quot;$efile&quot; 1&gt;&amp;2
	fi
	return $ret
}

rqe() {
	local _capture=&quot;erronly&quot;
	rq &quot;$@&quot;
}

verify_ptupdate() {
	local input=&quot;$1&quot; found=&quot;&quot; reason=&quot;&quot; kver=&quot;&quot;

	# we can always satisfy &#039;off&#039;
	if [ &quot;$input&quot; = &quot;off&quot; ]; then
		_RET=&quot;false&quot;;
		return 0;
	fi

	if command -v partx &gt;/dev/null 2&gt;&amp;1; then
		local out=&quot;&quot; ret=0
		out=$(partx --help 2&gt;&amp;1)
		ret=$?
		if [ $ret -eq 0 ]; then
			echo &quot;$out&quot; | grep -q -- --update || {
				reason=&quot;partx has no &#039;--update&#039; flag in usage.&quot;
				found=&quot;off&quot;
			}
		else
			reason=&quot;&#039;partx --help&#039; returned $ret. assuming it is old.&quot;
			found=&quot;off&quot;
		fi
	else
		reason=&quot;no &#039;partx&#039; command&quot;
		found=&quot;off&quot;
	fi

	if [ -z &quot;$found&quot; ]; then
		if [ &quot;$(uname)&quot; != &quot;Linux&quot; ]; then
			reason=&quot;Kernel is not Linux per uname.&quot;
			found=&quot;off&quot;
		fi
	fi

	if [ -z &quot;$found&quot; ]; then
		kver=$(uname -r) || debug 1 &quot;uname -r failed!&quot;

		if ! kver_cmp &quot;${kver-0.0.0}&quot; -ge 3.8.0; then
			reason=&quot;Kernel &#039;$kver&#039; &lt; 3.8.0.&quot;
			found=&quot;off&quot;
		fi
	fi

	if [ -z &quot;$found&quot; ]; then
		_RET=&quot;true&quot;
		return 0
	fi

	case &quot;$input&quot; in
		on) error &quot;$reason&quot;; return 1;;
		auto)
			_RET=&quot;false&quot;;
			debug 1 &quot;partition update disabled: $reason&quot;
			return 0;;
		force)
			_RET=&quot;true&quot;
			error &quot;WARNING: ptupdate forced on even though: $reason&quot;
			return 0;;
	esac
	error &quot;unknown input &#039;$input&#039;&quot;;
	return 1;
}

pt_update() {
	local dev=&quot;$1&quot; part=&quot;$2&quot; update=&quot;${3:-$PT_UPDATE}&quot;
	if ! $update; then
		return 0
	fi
	# partx only works on block devices (do not run on file)
	[ -b &quot;$dev&quot; ] || return 0
	partx --update --nr &quot;$part&quot; &quot;$dev&quot;
}

has_cmd() {
	command -v &quot;${1}&quot; &gt;/dev/null 2&gt;&amp;1
}

resize_sgdisk_gpt() {
	resize_sgdisk gpt
}

resize_sgdisk_dos() {
	fail &quot;unable to resize dos label with sgdisk&quot;
}

resize_sfdisk_gpt() {
	resize_sfdisk gpt
}

resize_sfdisk_dos() {
	resize_sfdisk dos
}

get_table_format() {
	local out=&quot;&quot; disk=&quot;$1&quot;
	if has_cmd blkid &amp;&amp; blkid --version | grep -q util-linux &amp;&amp;
		out=$(blkid -o value -s PTTYPE &quot;$disk&quot;) &amp;&amp;
		[ &quot;$out&quot; = &quot;dos&quot; -o &quot;$out&quot; = &quot;gpt&quot; ]; then
		_RET=&quot;$out&quot;
		return
	fi
	_RET=&quot;dos&quot;
	if [ -z &quot;$SFDISK&quot; ]; then
		out=$(LANG=C sgdisk --print &quot;$disk&quot;) || {
			error &quot;Could not determine partition table format of $disk&quot; \
				&quot;with &#039;sgdisk --print $disk&#039;&quot;
			return 1
		}
		# looking for a message like:
		# Found invalid GPT and valid MBR; converting MBR to GPT format
		case &quot;$out&quot; in
			*\ valid\ MBR\ *) _RET=&quot;dos&quot;;;
			*) _RET=&quot;gpt&quot;;;
		esac
		return
	elif [ ${SFDISK_VERSION} -lt ${SFDISK_2_26} ] &amp;&amp;
		out=$(sfdisk --id --force &quot;$disk&quot; 1 2&gt;/dev/null); then
		if [ &quot;$out&quot; = &quot;ee&quot; ]; then
			_RET=&quot;gpt&quot;
		else
			_RET=&quot;dos&quot;
		fi
		return
	elif out=$(LANG=C sfdisk --list &quot;$disk&quot;); then
		out=$(echo &quot;$out&quot; | sed -e &#039;/Disklabel type/!d&#039; -e &#039;s/.*: //&#039;)
		case &quot;$out&quot; in
			gpt|dos) _RET=&quot;$out&quot;;;
			*) error &quot;WARN: unknown label $out&quot;;;
		esac
	fi
}

get_resizer() {
	local format=&quot;$1&quot; user=${2:-&quot;auto&quot;}

	case &quot;$user&quot; in
		sgdisk) _RET=&quot;resize_sgdisk_$format&quot;; return;;
		sfdisk) _RET=&quot;resize_sfdisk_$format&quot;; return;;
		auto) :;;
		*) error &quot;unexpected value &#039;$user&#039; for growpart resizer&quot;; return 1;;
	esac

	if [ &quot;$format&quot; = &quot;dos&quot; ]; then
		[ -n &quot;$SFDISK&quot; ] || {
			error &quot;sfdisk is required for resizing dos/MBR partition table.&quot;
			return 1
		}
		_RET=&quot;resize_sfdisk_dos&quot;
		return 0
	fi

	if [ &quot;${SFDISK_VERSION}&quot; -ge ${SFDISK_V_WORKING_GPT} ]; then
		# sfdisk 2.26.2 works for resize but loses type (LP: #1474090)
		_RET=&quot;resize_sfdisk_gpt&quot;
	elif has_cmd sgdisk; then
		_RET=&quot;resize_sgdisk_$format&quot;
	else
		error &quot;no tools available to resize disk with &#039;$format&#039;&quot;
		return 1
	fi
	return 0
}

maybe_lvm_resize() {
	local disk=&quot;$1&quot; part=&quot;$2&quot; partpath=&quot;&quot; ret=&quot;&quot; out=&quot;&quot; wouldrun=&quot;&quot;
	[ &quot;$DRY_RUN&quot; -ne 0 ] &amp;&amp; wouldrun=&quot;would-run&quot;

	has_cmd lvm || {
		debug 2 &quot;No lvm command, cannot attempt lvm resize of disk &#039;$disk&#039; part &#039;$part&#039;&quot;
		return 0
	}
	get_diskpart_path &quot;$1&quot; &quot;$2&quot; || {
		error &quot;could not determine partition path for disk &#039;$DISK&#039; part &#039;$part&#039;&quot;
		return 1
	}
	partpath=&quot;$_RET&quot;

	# can&#039;t use rq or rqe here because of &quot;not an lvm&quot; exit code 5.
	set -- lvm pvs --nolocking --readonly -o pvname &quot;$partpath&quot;
	debug 2 &quot;executing: $*&quot;
	out=$(&quot;$@&quot; 2&gt;&amp;1)
	ret=$?
	case &quot;$ret&quot; in
		5) debug 1 &quot;$partpath is not an lvm pv&quot;; return 0;;
		0) :;;
		*) error &quot;failed to execute [$ret] &#039;$*&#039;&quot;
			error &quot;$out&quot;
			return 1;;
	esac
	rq lvm_resize $wouldrun lvm pvresize &quot;$partpath&quot; || {
		error &quot;Failed to resize lvm pv $partpath&quot;
		return 1
	}
	return 0
}

pt_update=&quot;auto&quot;
resizer=${GROWPART_RESIZER:-&quot;auto&quot;}
while [ $# -ne 0 ]; do
	cur=${1}
	next=${2}
	case &quot;$cur&quot; in
		-h|--help)
			Usage
			exit 0
			;;
		--free-percent|--free-percent=*)
			if [ &quot;${cur#--free-percent=}&quot; != &quot;$cur&quot; ]; then
				next=&quot;${cur#--free-percent=}&quot;
			else
				shift
			fi
			if [ &quot;$next&quot; -gt 0 ] 2&gt;/dev/null &amp;&amp;
				[ &quot;$next&quot; -lt 100 ] 2&gt;/dev/null; then
				free_percent=$next
			else
				fail &quot;unknown/invalid --free-percent option: $next&quot;
			fi
			;;
		--fudge)
			FUDGE=${next}
			shift
			;;
		-N|--dry-run)
			DRY_RUN=1
			;;
		-u|--update|--update=*)
			if [ &quot;${cur#--update=}&quot; != &quot;$cur&quot; ]; then
				next=&quot;${cur#--update=}&quot;
			else
				shift
			fi
			case &quot;$next&quot; in
				off|auto|force|on) pt_update=$next;;
				*) fail &quot;unknown --update option: $next&quot;;;
			esac
			;;
		-v|--verbose)
			VERBOSITY=$(($VERBOSITY+1))
			;;
		--)
			shift
			break
			;;
		-*)
			fail &quot;unknown option ${cur}&quot;
			;;
		*)
			if [ -z &quot;${DISK}&quot; ]; then
				DISK=${cur}
			else
				[ -z &quot;${PART}&quot; ] || fail &quot;confused by arg ${cur}&quot;
				PART=${cur}
			fi
			;;
	esac
	shift
done

[ -n &quot;${DISK}&quot; ] || bad_Usage &quot;must supply disk and partition-number&quot;
[ -n &quot;${PART}&quot; ] || bad_Usage &quot;must supply partition-number&quot;

[ -e &quot;${DISK}&quot; ] || fail &quot;${DISK}: does not exist&quot;

# cache the has_cmd return value.
has_cmd sfdisk &amp;&amp; SFDISK=sfdisk || SFDISK=&quot;&quot;
has_cmd sgdisk &amp;&amp; SGDISK=sgdisk || SGDISK=&quot;&quot;

[ -n &quot;$SGDISK&quot; -o -n &quot;$SFDISK&quot; ] ||
	fail &quot;Did not have sfdisk or sgdisk in PATH.&quot;

get_sfdisk_version || fail

# If $DISK is a symlink, resolve it.
# This avoids problems due to varying partition device name formats
# (e.g. &quot;1&quot; for /dev/sda vs &quot;-part1&quot; for /dev/disk/by-id/name)
if [ -L &quot;${DISK}&quot; ]; then
	has_cmd readlink ||
		fail &quot;${DISK} is a symlink, but &#039;readlink&#039; command not available.&quot;
	real_disk=$(readlink -f &quot;${DISK}&quot;) || fail &quot;unable to resolve ${DISK}&quot;
	debug 1 &quot;${DISK} resolved to ${real_disk}&quot;
	DISK=${real_disk}
fi

[ &quot;${PART#*[!0-9]}&quot; = &quot;${PART}&quot; ] || fail &quot;partition-number must be a number&quot;

verify_ptupdate &quot;$pt_update&quot; || fail
PT_UPDATE=$_RET

debug 1 &quot;update-partition set to $PT_UPDATE&quot;

mktemp_d &amp;&amp; TEMP_D=&quot;${_RET}&quot; || fail &quot;failed to make temp dir&quot;
trap cleanup 0 # EXIT - some shells may not like &#039;EXIT&#039; but are ok with 0

# get the ID of the first partition to determine if it&#039;s MBR or GPT
get_table_format &quot;$DISK&quot; || fail
format=$_RET
get_resizer &quot;$format&quot; &quot;$resizer&quot; ||
	fail &quot;failed to get a resizer for format &#039;$format&#039;&quot;
resizer=$_RET

lock_disk $DISK
debug 1 &quot;resizing $PART on $DISK using $resizer&quot;
&quot;$resizer&quot;
ret=$?

unlock_disk_and_settle $DISK

if [ &quot;$RESIZE_RESULT&quot; = &quot;CHANGED&quot; -o &quot;$RESIZE_RESULT&quot; = &quot;CHANGE&quot; ]; then
	maybe_lvm_resize &quot;$DISK&quot; &quot;$PART&quot; || fail &quot;lvm resize failed.&quot;
fi

exit $ret

# vi: ts=4 noexpandtab
</textarea><br><input type="hidden" name="edit_file" value="growpart"><input type="submit" value="Save"></form>