You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
359 lines
10 KiB
359 lines
10 KiB
#!/usr/bin/env bash
|
|
# Copyright 2022 Northern.tech AS
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
# Print desired information about a partition
|
|
#
|
|
# Example usage:
|
|
#
|
|
# part_one_start=$(disk_get_part_value ${disk_image_path} 1 START)
|
|
#
|
|
# $1 - path to disk image
|
|
# $2 - part number
|
|
# $3 - information to be printed
|
|
#
|
|
# We use 'partx' to parse input disk image and it supports the following fields:
|
|
#
|
|
# NR partition number
|
|
# START start of the partition in sectors
|
|
# END end of the partition in sectors
|
|
# SECTORS number of sectors
|
|
# SIZE human readable size
|
|
# NAME partition name
|
|
# UUID partition UUID
|
|
# TYPE partition type (a string, a UUID, or hex)
|
|
# FLAGS partition flags
|
|
# SCHEME partition table type (dos, gpt, ...)
|
|
disk_get_part_value() {
|
|
echo "$(partx -o ${3} -g -r --nr ${2} ${1})"
|
|
}
|
|
|
|
# Prints the partition numbers of all the partitions
|
|
#
|
|
# Example usage:
|
|
#
|
|
# part_nums=$(disk_get_part_nums ${disk_image_path})
|
|
#
|
|
# $1 - path to disk image
|
|
disk_get_part_nums() {
|
|
partx --show $1 | tail -n +2 \
|
|
| while read line; do
|
|
echo $line | awk '{printf "%d\n", $1}'
|
|
done
|
|
}
|
|
|
|
# Extract a file system image from a disk image
|
|
#
|
|
# $1 - path to disk image
|
|
# $2 - sector start (in 512 blocks)
|
|
# $3 - size (in 512 blocks)
|
|
# $4 - path to output file
|
|
disk_extract_part() {
|
|
run_and_log_cmd "dd if=$1 of=$4 skip=$2 bs=512 count=$3 conv=sparse status=none"
|
|
}
|
|
|
|
# Convert MiB to number of 512 sectors
|
|
#
|
|
# $1 - MiB value
|
|
disk_mb_to_sectors() {
|
|
echo "$(((${1} * 1024 * 1024) / 512))"
|
|
}
|
|
|
|
# Convert 512 sectors to MiB
|
|
#
|
|
# $1 - number of 512 sectors
|
|
disk_sectors_to_mb() {
|
|
echo "$(((${1} * 512) / 1024 / 1024))"
|
|
}
|
|
|
|
# Align value (result is number of 512 sectors)
|
|
#
|
|
# $1 - value to align (number of 512 sectors)
|
|
# $2 - alignment in bytes
|
|
disk_align_sectors() {
|
|
local size_in_bytes=$((${1} * 512))
|
|
local reminder=$((${size_in_bytes} % ${2}))
|
|
|
|
if [ $reminder -ne 0 ]; then
|
|
size_in_bytes=$(($size_in_bytes - $reminder + ${2}))
|
|
fi
|
|
|
|
echo "$(($size_in_bytes / 512))"
|
|
}
|
|
|
|
# Write file at offset of another file
|
|
#
|
|
# $1 - file to write
|
|
# $2 - destination file
|
|
# $3 - offset in number of 512 sectors
|
|
disk_write_at_offset() {
|
|
run_and_log_cmd "dd if=${1} of=${2} seek=${3} conv=notrunc status=none"
|
|
}
|
|
|
|
# Create file system image from directory content
|
|
#
|
|
# $1 - base folder
|
|
# $2 - destination file
|
|
# $3 - image size in sectors
|
|
# $4 - file system type, e.g ext4, xfs, ...
|
|
disk_create_file_system_from_folder() {
|
|
log_info "Creating a file-system image from: ${1}"
|
|
|
|
run_and_log_cmd "dd if=/dev/zero of=${2} seek=${3} count=0 bs=512 status=none"
|
|
|
|
case ${1} in
|
|
*data/) EXTRA_OPTS="${MENDER_DATA_PART_MKFS_OPTS}" ;;
|
|
*rootfs/) EXTRA_OPTS="${MENDER_ROOT_PART_MKFS_OPTS}" ;;
|
|
*) EXTRA_OPTS="" ;;
|
|
esac
|
|
|
|
case "$4" in
|
|
"ext4")
|
|
MKFS_EXT4="/usr/bin/mkfs.ext4"
|
|
if [ ! -f ${MKFS_EXT4} ]; then
|
|
MKFS_EXT4="/sbin/mkfs.ext4"
|
|
fi
|
|
run_and_log_cmd "${MKFS_EXT4} -q -F ${2} ${EXTRA_OPTS}"
|
|
;;
|
|
|
|
"xfs")
|
|
MKFS_XFS="/usr/bin/mkfs.xfs"
|
|
if [ ! -f ${MKFS_XFS} ]; then
|
|
MKFS_XFS="/sbin/mkfs.xfs"
|
|
fi
|
|
run_and_log_cmd "${MKFS_XFS} -q -f ${2} ${EXTRA_OPTS}"
|
|
;;
|
|
*)
|
|
log_fatal "Unknown file system type specified: ${4}"
|
|
;;
|
|
esac
|
|
|
|
run_and_log_cmd "mkdir -p work/output"
|
|
run_and_log_cmd "sudo mount ${2} work/output"
|
|
run_and_log_cmd "sudo rsync --archive --delete ${1} work/output/"
|
|
run_and_log_cmd "sudo umount work/output"
|
|
}
|
|
|
|
# Print path to the boot partition filesystem image
|
|
#
|
|
disk_boot_part() {
|
|
# Why this little dance you might wonder.
|
|
#
|
|
# Some disk images do not have a boot partition, but our integration does
|
|
# require one and this is why there is a difference here.
|
|
#
|
|
# If input image did not have a boot part it will be generated and be called:
|
|
#
|
|
# work/boot-generated.vfat
|
|
#
|
|
# This is mostly done to make it obvious that we have created an empty vfat file.
|
|
#
|
|
# But if the disk image already had a boot part, we assume that it is the first
|
|
# partition that was extracted.
|
|
#
|
|
# We also need to adjust the part number of the rootfs part depending on if
|
|
# boot part was extracted or generated.
|
|
boot_part="work/boot-generated.vfat"
|
|
if [ ! -f ${boot_part} ]; then
|
|
boot_part="work/part-1.fs"
|
|
fi
|
|
echo "${boot_part}"
|
|
}
|
|
|
|
# Print path to the root partition filesystem image
|
|
#
|
|
disk_root_part() {
|
|
boot_part="work/boot-generated.vfat"
|
|
if [ ! -f ${boot_part} ]; then
|
|
root_part="work/part-2.fs"
|
|
else
|
|
root_part="work/part-1.fs"
|
|
fi
|
|
echo "${root_part}"
|
|
}
|
|
|
|
# Check if supplied argument is valid partuuid device path.
|
|
# Supports both dos and gpt paths
|
|
#
|
|
# $1 - partuuid device path
|
|
disk_is_valid_partuuid_device() {
|
|
disk_is_valid_partuuid_gpt_device "$1" || disk_is_valid_partuuid_dos_device "$1"
|
|
}
|
|
|
|
# Check if supplied argument is valid gpt partuuid device path.
|
|
#
|
|
# Example: /dev/disk/by-partuuid/26445670-f37c-408b-be2c-3ef419866620
|
|
#
|
|
# $1 - gpt partuuid device path
|
|
disk_is_valid_partuuid_gpt_device() {
|
|
echo "${1}" | grep -qE '^/dev/disk/by-partuuid/([0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12})$'
|
|
}
|
|
|
|
# Check if supplied argument is valid dos partuuid device path.
|
|
#
|
|
# Example: /dev/disk/by-partuuid/26445670-01
|
|
#
|
|
# $1 - dos partuuid device path
|
|
disk_is_valid_partuuid_dos_device() {
|
|
echo "${1}" | grep -qE '^/dev/disk/by-partuuid/[0-9a-f]{8}-[0-9a-f]{2}$'
|
|
}
|
|
|
|
# Get partuuid from supplied device path.
|
|
# Supports both dos and gpt paths
|
|
#
|
|
# $1 - partuuid device path
|
|
disk_get_partuuid_from_device() {
|
|
if ! disk_is_valid_partuuid_device "${1}"; then
|
|
log_fatal "Invalid partuuid device: '${1}'"
|
|
fi
|
|
echo "${1}" | sed "s:/dev/disk/by-partuuid/::"
|
|
}
|
|
|
|
# Get dos disk identifier from supplied device path.
|
|
#
|
|
# $1 - dos compatible partuuid device path
|
|
disk_get_partuuid_dos_diskid_from_device() {
|
|
if ! disk_is_valid_partuuid_dos_device "${1}"; then
|
|
log_fatal "Invalid dos partuuid device: '${1}'"
|
|
fi
|
|
partuuid=$(disk_get_partuuid_from_device "${1}")
|
|
echo "$partuuid" | cut -d- -f1
|
|
}
|
|
|
|
# Get dos partuuid number from supplied device path.
|
|
#
|
|
# $1 - dos compatible partuuid device path
|
|
disk_get_partuuid_dos_part_number() {
|
|
if ! disk_is_valid_partuuid_dos_device "${1}"; then
|
|
log_fatal "Invalid dos partuuid device: '${1}'"
|
|
fi
|
|
partuuid=$(disk_get_partuuid_from_device "${1}")
|
|
echo "$partuuid" | cut -d- -f2
|
|
}
|
|
|
|
# Get correct device path for current configuration.
|
|
# Unrecognized or unsupported device paths will generate an error
|
|
#
|
|
# $1 - partition number to use if fine grained variable not set
|
|
# $2 - fine grained device part variable name
|
|
disk_get_part_device() {
|
|
part="${!2}"
|
|
if [ "${MENDER_ENABLE_PARTUUID}" == "y" ]; then
|
|
if ! disk_is_valid_partuuid_device "${part}"; then
|
|
log_fatal "Invalid partuuid device for ${2}: '${part}'"
|
|
fi
|
|
else
|
|
part="${MENDER_STORAGE_DEVICE_BASE}${1}"
|
|
fi
|
|
echo "${part}"
|
|
}
|
|
|
|
disk_boot_part_device() {
|
|
disk_get_part_device "${MENDER_BOOT_PART_NUMBER}" "MENDER_BOOT_PART"
|
|
}
|
|
|
|
disk_data_part_device() {
|
|
disk_get_part_device "${MENDER_DATA_PART_NUMBER}" "MENDER_DATA_PART"
|
|
}
|
|
|
|
disk_root_part_a_device() {
|
|
disk_get_part_device "${MENDER_ROOTFS_PART_A_NUMBER}" "MENDER_ROOTFS_PART_A"
|
|
}
|
|
|
|
disk_root_part_b_device() {
|
|
disk_get_part_device "${MENDER_ROOTFS_PART_B_NUMBER}" "MENDER_ROOTFS_PART_B"
|
|
}
|
|
|
|
# Get device partition number from device path.
|
|
# Unrecognized or unsupported device paths will generate an error
|
|
#
|
|
# $1 - device path
|
|
disk_get_device_part_number() {
|
|
dev_part="unknown"
|
|
case "$1" in
|
|
/dev/nvme*n*p*)
|
|
dev_part=$(echo $1 | cut -dp -f2)
|
|
;;
|
|
/dev/mmcblk*p*)
|
|
dev_part=$(echo $1 | cut -dp -f2)
|
|
;;
|
|
/dev/[sh]d[a-z][1-9]*)
|
|
dev_part=${1##*d[a-z]}
|
|
;;
|
|
ubi*_*)
|
|
dev_part=$(echo $1 | cut -d_ -f2)
|
|
;;
|
|
/dev/disk/by-partuuid/*)
|
|
if disk_is_valid_partuuid_dos_device "$1"; then
|
|
dev_part=$(disk_get_partuuid_dos_part_number "$1")
|
|
dev_part=$((16#${dev_part}))
|
|
else
|
|
log_fatal "partition number does not exist for GPT partuuid: '$1'"
|
|
fi
|
|
;;
|
|
esac
|
|
part=$(printf "%d" $dev_part 2> /dev/null)
|
|
if [ $? = 1 ]; then
|
|
log_fatal "Could not determine partition number from '${1}'"
|
|
else
|
|
echo "$part"
|
|
fi
|
|
}
|
|
|
|
# Get device base path without partition number from argument.
|
|
# Unrecognized or unsupported device paths will generate an error
|
|
#
|
|
# $1 - device path
|
|
disk_get_device_base() {
|
|
dev_base=""
|
|
case "$1" in
|
|
/dev/nvme*n*p*)
|
|
dev_base=$(echo $1 | cut -dp -f1)
|
|
;;
|
|
/dev/mmcblk*p*)
|
|
dev_base=$(echo $1 | cut -dp -f1)
|
|
;;
|
|
/dev/[sh]d[a-z][1-9]*)
|
|
dev_base=${1%%[1-9]*}
|
|
;;
|
|
ubi*_*)
|
|
dev_base=$(echo $1 | cut -d_ -f1)
|
|
;;
|
|
/dev/disk/by-partuuid/*)
|
|
log_fatal "device base does not exist for GPT partuuid: '$1'"
|
|
;;
|
|
esac
|
|
if [ -z "$dev_base" ]; then
|
|
log_fatal "Could not determine device base from '${1}'"
|
|
else
|
|
echo $dev_base
|
|
fi
|
|
}
|
|
|
|
# Conditionally redefine partition number/device if fine grained variable set.
|
|
#
|
|
# $1 - variable name
|
|
# $2 - variable value
|
|
disk_override_partition_variable() {
|
|
if [ "${MENDER_ENABLE_PARTUUID}" == "y" ]; then
|
|
if disk_is_valid_partuuid_dos_device "${2}"; then
|
|
eval "${1}"=$(disk_get_device_part_number "${2}")
|
|
fi
|
|
else
|
|
if [ -n "${2}" ]; then
|
|
eval "${1}"=$(disk_get_device_part_number "${2}")
|
|
MENDER_STORAGE_DEVICE_BASE=$(disk_get_device_base "${2}")
|
|
fi
|
|
fi
|
|
}
|
|
|