1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
#!/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
# 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* -type b); do
dev_get_type "$dev" || continue
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 devn pstart
dev=
mbrid=
uuid=
label=
number=
[ -b "$1" ] || return 1
part="$( readlink -f "$1" )"
partn="${part##*/}"
for devn in "${partn%p?}" "${partn%?}"; do
if [ "$dev" != "$part" ] && [ -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" )"
local gpt=
if [ "$( dd if="$dev" bs=1 count=8 skip=512 2> /dev/null )" = "EFI PART" ]; then
gpt=512
elif [ "$( dd if="$dev" bs=1 count=8 skip=4096 2> /dev/null )" = "EFI PART" ]; then
gpt=4096
fi
if [ -z "$label" ] && [ "$number" -lt 1000 ] && [ "$number" -gt 0 ] \
&& [ "$( __read_mbrsig "$dev" 0 )" = "55aa" ]; then
# Get MBR ID
if [ "$number" -le 4 ]; then
# Primary
mbrid="$( __read_mbrid "$dev" 0 "$number" )"
else
# Scan for Primary type 05, 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" )"
echo "Scanning. Primary $no is type $id" >&2
[ "$id" = "05" ] && break
done
if [ "$id" != "05" ]; then
echo "No matching extended primary partition found" >&2
return 1
fi
ex_start="$( __read_mbrstart "$dev" 0 "$no" )"
current="$ex_start"
no=5 # Count through logical partitions
while [ "$no" != 0 ]; do
[ "$( __read_mbrsig "$dev" "$current" )" = "55aa" ] || break
log_id="$( __read_mbrid "$dev" "$current" 1 )"
if [ "$no" = "$number" ]; then
log_start="$( __read_mbrstart "$dev" "$current" 1 )"
log_start="$(( log_start + current ))"
if [ "$pstart" != "$log_start" ]; then
echo "Found partition $no, but start mismatch (want: $pstart found: $log_start)" >&2
return 1
fi
mbrid="$log_id"
break
fi
next_id="$( __read_mbrid "$dev" "$current" 2 )"
next_start="$( __read_mbrstart "$dev" "$current" 2 )"
echo "Extended id $log_id, next $next_id, $next_start" >&2
if [ "$next_id" = "05" ] && [ "$next_start" -gt 0 ]; then
current="$(( next_start + ex_start ))"
no="$(( no + 1 ))"
else
return 1 # End of linked list
fi
done
fi
return 0
elif [ -n "$gpt" ]; then
# GPT
local table_start current entries no entry_size log_start
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 table. 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 \
| xxd -p | sed -r 's/^(..)(..)(..)(..)(..)(..)(..)(..)(....)/\4\3\2\1-\6\5-\8\7-\9-/' )"
return 0
fi
# Unknown
return 1
}
# 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 | xxd -p
}
# 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 | xxd -p
}
# 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 | xxd -e -g "$3" | cut -d' ' -f2 )"
echo $(( 0x$v ))
}
|
