#!/bin/ash
# Get all partitions with given id (list of /dev/sdXX)
# Works for MBR/DOS by looking at the type (1 byte)
# and for GPT by looking for the label 'OpenSLX-ID$1'
# in case an id was given, or with the given UUID,
# or with the given name.
# The output will be a list of matching devices,
# sorted from largest to smallest.
dev_find_partitions() {
local ID dev target rw
# check if only interested in writable devices
rw=
if [ "$1" = "--rw" ]; then
shift
rw=1
fi
# target for the scan, defaults to /dev to check everything
if [ "${1:0:1}" = "/" ] && [ -b "$1" ]; then
target="$1"
shift
elif [ "${1:0:1}" = "/" ] && [ -d "$1" ]; then
target="$1/"
shift
else
target="/dev/"
fi
local want_label="never match this#"
local want_type="never match this#"
local want_uuid="never match this#"
while [ "$#" -gt 0 ]; do
ID="$1"
shift
[ -z "$ID" ] && continue
if regex_imatch "$ID" "^[0-9a-f]$"; then
want_type="$want_type|0$ID"
want_label="$want_label|OpenSLX-ID0$ID"
elif regex_imatch "$ID" "^[0-9a-f]{2}$"; then
want_type="$want_type|$ID"
want_label="$want_label|OpenSLX-ID$ID"
elif regex_imatch "$ID" "^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$"; then
want_uuid="$want_uuid|$ID"
elif [ "${#ID}" -gt 3 ]; then # Safety measure: Want label length >= 4 chars
want_label="$want_label|$( regex_escape "$ID" )"
fi
done
local label number mbrid uuid
for dev in $(find $target* -maxdepth 0 -type b); do
[ -n "$rw" ] && [ "$( cat "/sys/class/block/${dev##*/}/ro" )" = "1" ] && continue
dev_get_type "$dev" || continue
is_on "$SLX_DEBUG" && echo "$dev is $number - MBR=$mbrid, UUID=$uuid, label=$label" >&2
if regex_imatch "$mbrid" "^($want_type)$" || regex_imatch "$uuid" "^($want_uuid)$" \
|| regex_match "$label" "^($want_label)$"; then
printf "%s\n" "$(blockdev --getsize64 "$dev") $dev"
fi
done | sort -n -k1 -r | cut -d' ' -f2
}
# Pass partition block device. If it could be identified successfully,
# fills the variables number, mbrid, uuid, label, depending on MBR/GPT.
# Otherwise, return code is != 0 and contents are undefined.
# This only makes sense if called within this script, or if slx-tools
# was sourced, otherwise the variables will be inaccessible.
dev_get_type() {
local part dev partn devlist devn pstart
dev=
mbrid=
uuid=
label=
number=
[ -b "$1" ] || return 1
part="$( readlink -f "$1" )"
partn="${part##*/}"
devlist="$( printf "%s" "$partn" | sed -r 's/[0-9]+$//' )"
[ "$partn" = "$devlist" ] && return 1
for devn in "${devlist}" "${devlist%p}"; do
if [ -f "/sys/block/${devn}/${partn}/uevent" ]; then
dev="/dev/${devn}"
break
fi
done
[ -z "$dev" ] && return 1
pstart="$( cat "/sys/block/${devn}/${partn}/start" )" # For validation
label="$( grep -Po '(?<=^PARTNAME=).*$' "/sys/block/${devn}/${partn}/uevent" )"
number="$( grep -Po '(?<=^PARTN=).*$' "/sys/block/${devn}/${partn}/uevent" )"
number="$( cat "/sys/block/${devn}/${partn}/partition" )"
local gpt=
if [ "$( dd if="$dev" bs=1 count=8 skip=512 )" = "EFI PART" ]; then
gpt=512
elif [ "$( dd if="$dev" bs=1 count=8 skip=4096 )" = "EFI PART" ]; then
gpt=4096
fi 2> /dev/null
is_on "$SLX_DEBUG" && echo "Checking $partn (on $dev) GPT='$gpt', label='$label'" >&2
# Check if mbr signatur is there, no GPT label was in uevent, and no protective MBR
local t1="$( __read_mbrid "$dev" 0 1 )"
if [ -z "$label" ] && [ "$number" -lt 1000 ] && [ "$number" -gt 0 ] \
&& [ "$t1" != "ee" ] && [ "$( __read_mbrsig "$dev" 0 )" = "55aa" ]; then
# Then we consider parsing this as MBR
if [ "$number" -le 4 ]; then # 1-4 are primary partitions
# Validate start LBA matches sysfs
log_start="$( __read_mbrstart "$dev" 0 "$number" )"
if [ "$pstart" != "$log_start" ]; then
echo "Found partition $number on $dev, but start mismatch (want: $pstart found: $log_start)" >&2
else
mbrid="$( __read_mbrid "$dev" 0 "$number" )"
return 0
fi
else # part number 5+ -- must be logical volume in extended partition
# Scan for Primary type 05/0f, scan linked list of fake MBRs from there
local no id ex_start log_id log_start next_id next_start current
for no in 1 2 3 4; do
id="$( __read_mbrid "$dev" 0 "$no" )"
if [ "$id" = "05" ] || [ "$id" = "0f" ]; then
id="found"
break
fi
done
if [ "$id" != "found" ]; then
echo "No matching extended primary partition for $number found on $dev" >&2
else
is_on "$SLX_DEBUG" && echo "Primary $no is extended partition" >&2
ex_start="$( __read_mbrstart "$dev" 0 "$no" )"
current="$ex_start"
no=5 # Count through logical partitions. These start at 5.
while [ "$no" -le "$number" ]; do
if [ "$( __read_mbrsig "$dev" "$current" )" != "55aa" ]; then
echo "Unexpected end of logical partition at $no of $number on $dev" >&2
break
fi
log_id="$( __read_mbrid "$dev" "$current" 1 )"
if [ "$no" -eq "$number" ]; then
log_start="$( __read_mbrstart "$dev" "$current" 1 )"
# logical partition's start is relative to its fake MBR
log_start="$(( log_start + current ))"
if [ "$pstart" != "$log_start" ]; then
echo "Found partition $no on $dev, but start mismatch (want: $pstart found: $log_start)" >&2
break
fi
mbrid="$log_id"
return 0
fi
next_id="$( __read_mbrid "$dev" "$current" 2 )"
# next logical partition's fake MBR is relative to the extended partition's start
next_start="$( __read_mbrstart "$dev" "$current" 2 )"
is_on "$SLX_DEBUG" && echo "Extended id $log_id, next $next_id, $next_start" >&2
[ "$next_id" = "0f" ] && next_id="05"
if [ "$next_id" = "05" ] && [ "$next_start" -ge 512 ]; then
current="$(( next_start + ex_start ))"
no="$(( no + 1 ))" # Increase counter for next logical partition
else
break
fi
done
fi
fi
fi
if [ -n "$gpt" ]; then
# GPT
local table_start current entries no entry_size log_start readoff num byte
table_start="$( __read_le "$dev" "$(( gpt + 72 ))" 8 )"
entries="$( __read_le "$dev" "$(( gpt + 80 ))" 4 )"
entry_size="$( __read_le "$dev" "$(( gpt + 84 ))" 4 )"
current="$(( table_start * gpt ))"
if ! [ "$current" -ge "$(( gpt * 2 ))" ] || ! [ "$entries" -gt 0 ] \
|| [ "$entries" -lt "$number" ] || ! [ "$entry_size" -le 4096 ]; then
echo "Bad GPT. Start: $current, Partition count: $entries. Want: $number" >&2
return 1
fi
log_start="$( __read_le "$dev" "$(( current + entry_size * (number - 1) + 32 ))" 8 )"
if [ "$log_start" != "$pstart" ]; then
echo "Found partition $number, but start mismatch (want: $pstart found: $log_start)" >&2
return 1
fi
# Convert raw hex stream to proper string representation. First 3 groups are little endian.
uuid="$( dd if="$dev" bs=1 count=16 skip="$(( current + entry_size * (number - 1) ))" 2> /dev/null \
| __bin2hex | sed -r 's/^(..)(..)(..)(..)(..)(..)(..)(..)(....)/\4\3\2\1-\6\5-\8\7-\9-/' )"
if [ -z "$label" ]; then
readoff="$(( current + entry_size * (number - 1) + 56 ))"
num=0
while [ "$num" -lt 36 ]; do
byte="$( __read_le "$dev" "$readoff" "1" )"
if [ "$byte" -ge 32 ] && [ "$byte" -le 126 ]; then
byte="$( dd if="$dev" bs=1 count="1" skip="$readoff" 2> /dev/null )"
label="$label$byte"
fi
readoff=$(( readoff + 2 ))
num=$(( num + 1 ))
done
fi
return 0
fi
# Unknown
return 1
}
# Get version of given swap partition. $1 will be checked for the
# swap signature, and if found, the version number will be returned.
# old-style swap will be reported as version 1,
# new-style as 1 + <version_field>.
dev_swap_version() {
local sig version
sig="$( dd if="$1" bs=1 count=10 skip=4086 2> /dev/null )"
if [ "$sig" = "SWAP-SPACE" ]; then
echo 1
return 0
elif [ "$sig" = "SWAPSPACE2" ]; then
version="$( __read_le "$1" 1024 4 )"
# I think there is only '1' currently, but try to be clever...
if [ "$version" -gt 0 ] && [ "$version" -lt 8 ]; then
echo $(( 1 + version ))
return 0
fi
fi
return 1
}
# stdin = binary data, stdout = raw, unformatted hex
# __hex2bin()
# stdin = binary data, stdout = raw, unformatted hex
# $1 = number of bytes to read and reverse (1, 2, 4, 8)
# __hex2bin_le()
# Get MBR type of partition (1 byte) as hex
# Pass "$device" "$lba_offset" "$partition_number"
__read_mbrid() {
dd if="$1" bs=1 skip=$(( 512 * $2 + 446 + ($3 - 1) * 16 + 4 )) count=1 2> /dev/null | __bin2hex
}
# Get LBA start address of MBR partition
# Pass "$device" "$lba_offset" "$partition_number"
__read_mbrstart() {
__read_le "$1" "$(( 512 * $2 + 446 + ($3 - 1) * 16 + 8 ))" 4
}
# Read the MBR signature in the given sector
# Pass "$device" "$lba_offset"
__read_mbrsig() {
dd if="$1" bs=1 skip=$(( 512 * $2 + 510 )) count=2 2> /dev/null | __bin2hex
}
# Read a little endian value at given byte offset
# Pass "$source_path" "$byte_offset" "$size"
__read_le() {
local v="$( dd if="$1" bs=1 count="$3" skip="$2" 2> /dev/null | __bin2hex_le "$3" )"
echo $(( 0x$v ))
}
__init() {
local t
# init __hex2bin
t="7a32337465737431323374657374"
if [ "$( printf z23test123test | xxd -p | tr -d '\n ' )" = "$t" ]; then
#echo "Using xxd" >&2
__bin2hex() { xxd -p | tr -d '\n '; }
elif [ "$( printf z23test123test | od -t x1 -An | tr -d '\n ' )" = "$t" ]; then
#echo "Using od" >&2
__bin2hex() { od -t x1 -An | tr -d '\n '; }
elif [ "$( printf z23test123test | hexdump -ve '/1 "%02x"' )" = "$t" ]; then
#echo "Using hexdump" >&2
__bin2hex() { hexdump -ve '/1 "%02x"'; }
else
echo "No suitable tool for converting binary to hex"
exit 1
fi >&2 2> /dev/null
# init __hex2bin_le
t="383736353433327a"
if [ "$( printf z2345678 | xxd -e -g 8 | cut -d' ' -f2 )" = "$t" ]; then
#echo "Using xxd" >&2
__bin2hex_le() { xxd -e -g "$1" | cut -d' ' -f2; }
elif [ "$( printf z2345678 | od -t x8 -An | tr -d '\n ' )" = "$t" ]; then
#echo "Using od" >&2
__bin2hex_le() { od -t "x$1" -An | tr -d '\n '; }
elif [ "$( printf z2345678 | hexdump -ve '/4 "%02x"' \
| sed 's/\(........\)\(........\)/\2\1/' )" = "$t" ]; then
#echo "Using hexdump" >&2
__bin2hex_le() {
if [ "$1" -lt 8 ]; then
hexdump -ve "/$1"' "%02x"'
else
hexdump -ve '/4 "%02x"' | sed 's/\(........\)\(........\)/\2\1/'
fi
}
elif [ "$( printf z2345678 | xxd -g 8 | cut -d' ' -f2 | awk '{ for (i=length-1;i>0;i-=2)x=x substr($0,i,2);}END{print x}' )" = "$t" ]; then
__bin2hex_le() { xxd -g "$1" | cut -d' ' -f2 | awk '{ for (i=length-1;i>0;i-=2)x=x substr($0,i,2);}END{print x}'; }
else
echo "No suitable tool for converting binary data to little endian hex"
exit 1
fi >&2 2> /dev/null
unset -f __init
}
__init
