shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-22 17:35:59 +03:00
Code Releases Activity
847f1dd99c
lvm2/test/shell/devicesfile-serial.sh

891 lines
22 KiB
Bash
Raw Normal View History

device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
#!/usr/bin/env bash
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
# Copyright (C) 2020-23 Red Hat, Inc. All rights reserved.
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions
# of the GNU General Public License v.2.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
test_description='device id wwid from vpd_pg83'
tests: skip some unneeded test Skip irelevant tests for polld & lockd pass.
2023-04-23 20:17:08 +03:00
SKIP_WITH_LVMPOLLD=1
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
. lib/inittest
tests: check for loaded brd Skip the test if the brd is already loaded in the system.
2023-07-17 14:21:59 +03:00
test -d /sys/block/ram0 && skip "Ramdisk already loaded"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
test "$DM_DEV_DIR" = "/dev" || skip "Only works with /dev access -> make check LVM_TEST_DEVDIR=/dev"
# requires trailing / to match dm
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
SYS_DIR="$PWD/test/sys"
aux lvmconf "devices/use_devicesfile = 1" \
"devices/device_id_sysfs_dir = \"$SYS_DIR/\""
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# The string format of the serial numbers
# encoded in the pg80 files
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
SERIAL1="003dd33a331c183c2300e1d883604609"
SERIAL2="003dd33a441c183c2300e1d883604609"
SERIAL3="003dd33a551c183c2300e1d883604609"
SERIAL4="003dd33a661c183c2300e1d883604609"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
create_base() {
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
mkdir -p "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device"
mkdir -p "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device"
mkdir -p "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device"
mkdir -p "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# Create four different pg80 serial numbers that
# can be assigned to devs
echo -n "0080 0020 3030 3364 6433 3361 3333 3163 \
3138 3363 3233 3030 6531 6438 3833 3630 3436 3039" | xxd -r -p > pg80_1
echo -n "0080 0020 3030 3364 6433 3361 3434 3163 \
3138 3363 3233 3030 6531 6438 3833 3630 3436 3039" | xxd -r -p > pg80_2
echo -n "0080 0020 3030 3364 6433 3361 3535 3163 \
3138 3363 3233 3030 6531 6438 3833 3630 3436 3039" | xxd -r -p > pg80_3
echo -n "0080 0020 3030 3364 6433 3361 3636 3163 \
3138 3363 3233 3030 6531 6438 3833 3630 3436 3039" | xxd -r -p > pg80_4
}
remove_base() {
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
rm -rf "$SYS_DIR"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
}
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cleanup_and_teardown()
{
remove_base
rmmod brd
aux teardown
}
trap 'cleanup_and_teardown' EXIT
modprobe brd rd_nr=4 || skip
sleep 1
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
remove_base
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
dev1="/dev/ram0"
dev2="/dev/ram1"
dev3="/dev/ram2"
dev4="/dev/ram3"
devs=( "$dev1" "$dev2" "$dev3" "$dev4" )
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
DFDIR="$LVM_SYSTEM_DIR/devices"
mkdir -p "$DFDIR" || true
DF="$DFDIR/system.devices"
ORIG="$DFDIR/orig.devices"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
touch "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
vgcreate $vg1 "$dev1"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
eval "$(pvs --noheading --nameprefixes -o major,minor,uuid "$dev1")"
MAJOR1=$LVM2_PV_MAJOR
MINOR1=$LVM2_PV_MINOR
OPVID1=$LVM2_PV_UUID
PVID1=${OPVID1//-/}
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
vgcreate $vg2 "$dev2"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
eval "$(pvs --noheading --nameprefixes -o major,minor,uuid "$dev2")"
MAJOR2=$LVM2_PV_MAJOR
MINOR2=$LVM2_PV_MINOR
OPVID2=$LVM2_PV_UUID
PVID2=${OPVID2//-/}
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
vgcreate $vg3 "$dev3"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
eval "$(pvs --noheading --nameprefixes -o major,minor,uuid "$dev3")"
MAJOR3=$LVM2_PV_MAJOR
MINOR3=$LVM2_PV_MINOR
OPVID3=$LVM2_PV_UUID
PVID3=${OPVID3//-/}
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
vgcreate $vg4 "$dev4"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
eval "$(pvs --noheading --nameprefixes -o major,minor,uuid "$dev4")"
MAJOR4=$LVM2_PV_MAJOR
MINOR4=$LVM2_PV_MINOR
OPVID4=$LVM2_PV_UUID
PVID4=${OPVID4//-/}
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
create_base
# get serial number from pg80
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp pg80_1 "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/vpd_pg80"
cp pg80_2 "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/vpd_pg80"
cp pg80_3 "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/vpd_pg80"
cp pg80_4 "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/vpd_pg80"
grep -r "" "$SYS_DIR/dev/block/"
declare -A serials=( ["$dev1"]=$SERIAL1 ["$dev2"]=$SERIAL2 \
["$dev3"]=$SERIAL3 ["$dev4"]=$SERIAL4 )
rm -f "$DF"
for i in "${devs[@]}"
do
lvmdevices --adddev "$i"
grep "${serials["$i"]}" "$DF" || {
cat "$DF"
die "Cannot find ${serials["$i"]}"
}
done
cat "$DF"
cp "$DF" "$ORIG"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs
# run command to update metadata so deviceids are written to metadata
vgchange --addtag x $vg1
vgchange --addtag x $vg2
vgchange --addtag x $vg3
vgchange --addtag x $vg4
pvs -o uuid,deviceidtype,deviceid "$dev1" |tee out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$OPVID1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o uuid,deviceidtype,deviceid "$dev2" |tee out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$OPVID2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# get serial number from device/serial
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
rm "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/vpd_pg80"
rm "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/vpd_pg80"
rm "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/vpd_pg80"
rm "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/vpd_pg80"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL3" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL4" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
pvcreate "$dev1"
pvcreate "$dev2"
pvcreate "$dev3"
pvcreate "$dev4"
grep "$SERIAL1" "$DF"
grep "$SERIAL2" "$DF"
grep "$SERIAL3" "$DF"
grep "$SERIAL4" "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# all pvs have the same serial number
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg2 "$dev2"
vgcreate $vg3 "$dev3"
vgcreate $vg4 "$dev4"
cp "$DF" "$ORIG"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
PVID4=${OPVID4//-/}
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID2" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev2" out
grep "$PVID3" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev3" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev4" out
pvs -o+uuid,deviceidtype,deviceid "${devs[@]}" |tee out
grep "$dev1" out
grep "$dev2" out
grep "$dev3" out
grep "$dev4" out
grep "$OPVID1" out
grep "$OPVID2" out
grep "$OPVID3" out
grep "$OPVID4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
grep $vg2 out
grep $vg3 out
grep $vg4 out
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev1" |tee out
grep "$OPVID1" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev2" |tee out
grep "$OPVID2" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg2 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev3" |tee out
grep "$OPVID3" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg3 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev4" |tee out
grep "$OPVID4" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg4 out
# all pvs have the same serial number, df devnames are stale
# edit DF to make devnames stale
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=tmpnm|" orig > tmp1
sed -e "s|DEVNAME=$dev2|DEVNAME=$dev1|" tmp1 > tmp2
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev2|" tmp2 > tmp3
sed -e "s|DEVNAME=$dev3|DEVNAME=tmpnm|" tmp3 > tmp4
sed -e "s|DEVNAME=$dev4|DEVNAME=$dev3|" tmp4 > tmp5
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev4|" tmp5 > "$DF"
cat "$DF"
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" |tee out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$dev4" out |tee out4
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
grep "$OPVID4" out4
grep "$SERIAL1" out1
grep "$SERIAL1" out2
grep "$SERIAL1" out3
grep "$SERIAL1" out4
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID2" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev2" out
grep "$PVID3" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev3" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o+uuid,deviceid "$dev1"|tee out1
pvs -o+uuid,deviceid "$dev2"|tee out2
pvs -o+uuid,deviceid "$dev3"|tee out3
pvs -o+uuid,deviceid "$dev4"|tee out4
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
grep "$OPVID4" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# all pvs have the same serial number,
# dev1 and dev2 have devnames swapped,
# dev3 has stale PVID in the DF.
# lvm fixes the stale devnames but does not fix the stale PVID
# because of the duplicate serial numbers, so dev3 is not found
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=tmpnm|" orig > tmp1
sed -e "s|DEVNAME=$dev2|DEVNAME=$dev1|" tmp1 > tmp2
sed -e "s|PVID=$PVID4|PVID=4SqT4onBxSiv4dot0GRDPtrWqOlrOPH1|" tmp2 > "$DF"
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" > out || true
cat out
not grep "$dev4" out
not grep "$OPVID4" out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
not pvs "$dev4"
# dev1&2 have same serial, dev3&4 have same serial
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg2 "$dev2"
vgcreate $vg3 "$dev3"
vgcreate $vg4 "$dev4"
cp "$DF" "$ORIG"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
PVID4=${OPVID4//-/}
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID2" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev2" out
grep "$PVID3" "$DF" |tee out
grep "$SERIAL2" out
grep "$dev3" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL2" out
grep "$dev4" out
pvs -o+uuid,deviceidtype,deviceid "${devs[@]}" |tee out
grep "$dev1" out
grep "$dev2" out
grep "$dev3" out
grep "$dev4" out
grep "$OPVID1" out
grep "$OPVID2" out
grep "$OPVID3" out
grep "$OPVID4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
grep $vg2 out
grep $vg3 out
grep $vg4 out
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out
grep "$SERIAL2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev1" |tee out
grep "$OPVID1" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev2" |tee out
grep "$OPVID2" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg2 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev3" |tee out
grep "$OPVID3" out
grep "$SERIAL2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg3 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev4" |tee out
grep "$OPVID4" out
grep "$SERIAL2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg4 out
# dev1&2 have serial1 and dev3&4 have serial2, swap devnames
# edit DF to make devnames stale
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=tmpnm|" orig > tmp1
sed -e "s|DEVNAME=$dev3|DEVNAME=$dev1|" tmp1 > tmp2
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev3|" tmp2 > tmp3
sed -e "s|DEVNAME=$dev2|DEVNAME=tmpnm|" tmp3 > tmp4
sed -e "s|DEVNAME=$dev4|DEVNAME=$dev2|" tmp4 > tmp5
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev4|" tmp5 > "$DF"
cat "$DF"
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" |tee out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$dev4" out |tee out4
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
grep "$OPVID4" out4
grep "$SERIAL1" out1
grep "$SERIAL1" out2
grep "$SERIAL2" out3
grep "$SERIAL2" out4
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID2" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev2" out
grep "$PVID3" "$DF" |tee out
grep "$SERIAL2" out
grep "$dev3" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL2" out
grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o+uuid,deviceid "$dev1"|tee out1
pvs -o+uuid,deviceid "$dev2"|tee out2
pvs -o+uuid,deviceid "$dev3"|tee out3
pvs -o+uuid,deviceid "$dev4"|tee out4
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$OPVID1" out1
grep "$SERIAL1" out1
grep "$OPVID2" out2
grep "$SERIAL1" out2
grep "$OPVID3" out3
grep "$SERIAL2" out3
grep "$OPVID4" out4
grep "$SERIAL2" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# all devs have same serial, dev1&4 are pvs, dev2&3 are not pvs
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg4 "$dev4"
cp "$DF" "$ORIG"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID4=${OPVID4//-/}
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o+uuid,deviceidtype,deviceid |tee out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$dev1" out
grep "$dev4" out
grep "$OPVID1" out
grep "$OPVID4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
grep $vg4 out
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev1" |tee out
grep "$OPVID1" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
not pvs -o+uuid,deviceid "$dev2"
not pvs -o+uuid,deviceid "$dev3"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "$dev4" |tee out
grep "$OPVID4" out
grep "$SERIAL1" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg4 out
# edit DF to make devnames stale
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=$dev2|" orig > tmp1
sed -e "s|DEVNAME=$dev4|DEVNAME=$dev3|" tmp1 > "$DF"
cat "$DF"
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" > out || true
cat out
grep "$dev1" out |tee out1
grep "$dev4" out |tee out4
grep "$OPVID1" out1
grep "$OPVID4" out4
grep "$SERIAL1" out1
grep "$SERIAL1" out4
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o+uuid,deviceid "$dev1"|tee out1
pvs -o+uuid,deviceid "$dev4"|tee out4
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$OPVID1" out1
grep "$SERIAL1" out1
grep "$OPVID4" out4
grep "$SERIAL1" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# one pv with serial, three other non-pvs with same serial
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
rm "$DF"
touch "$DF"
vgcreate $vg2 "$dev2"
cp "$DF" "$ORIG"
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
PVID2=${OPVID2//-/}
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$PVID2" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
pvs -o+uuid,deviceidtype,deviceid |tee out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$dev2" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep sys_serial out
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out
not grep "$dev1" out
not grep "$dev3" out
not grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# edit DF to make devname stale
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev2|DEVNAME=$dev3|" orig > "$DF"
cat "$DF"
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" > out || true
cat out
grep "$dev2" out
grep "$OPVID2" out
grep "$SERIAL1" out
grep "$dev2" "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# different serial numbers, stale pvid and devname in df,
# lvm corrects pvid in df because serial number is unique
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL3" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL4" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg2 "$dev2"
vgcreate $vg3 "$dev3"
vgcreate $vg4 "$dev4"
cp "$DF" "$ORIG"
grep "$SERIAL1" "$DF"
grep "$SERIAL2" "$DF"
grep "$SERIAL3" "$DF"
grep "$SERIAL4" "$DF"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
PVID4=${OPVID4//-/}
pvs -o+uuid,deviceid "${devs[@]}"
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|PVID=$PVID1|PVID=bad14onBxSiv4dot0GRDPtrWqOlr1bad|" orig > tmp1
sed -e "s|PVID=$PVID3|PVID=bad24onBxSiv4dot0GRDPtrWqOlr2bad|" tmp1 > tmp2
sed -e "s|DEVNAME=$dev1|DEVNAME=.|" tmp2 > "$DF"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cat "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" |tee out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$dev4" out |tee out4
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
grep "$OPVID4" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out1
grep $vg2 out2
grep $vg3 out3
grep $vg4 out4
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out1
grep "$SERIAL2" out2
grep "$SERIAL3" out3
grep "$SERIAL4" out4
grep "$PVID1" "$DF" |tee out
grep "$SERIAL1" out
grep "$dev1" out
grep "$PVID2" "$DF" |tee out
grep "$SERIAL2" out
grep "$dev2" out
grep "$PVID3" "$DF" |tee out
grep "$SERIAL3" out
grep "$dev3" out
grep "$PVID4" "$DF" |tee out
grep "$SERIAL4" out
grep "$dev4" out
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# duplicate serial on two pvs, two pvs with devname type, all devnames stale
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg2 "$dev2"
vgcreate $vg3 "$dev3"
vgcreate $vg4 "$dev4"
cp "$DF" "$ORIG"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
PVID4=${OPVID4//-/}
cat "$DF"
pvs -o+uuid,deviceid "${devs[@]}"
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=tmpnm|" orig > tmp1
sed -e "s|DEVNAME=$dev3|DEVNAME=$dev1|" tmp1 > tmp2
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev3|" tmp2 > tmp3
sed -e "s|DEVNAME=$dev2|DEVNAME=tmpnm|" tmp3 > tmp4
sed -e "s|DEVNAME=$dev4|DEVNAME=$dev2|" tmp4 > tmp5
sed -e "s|DEVNAME=tmpnm|DEVNAME=$dev4|" tmp5 > "$DF"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cat "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" |tee out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$dev4" out |tee out4
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
grep "$OPVID4" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out1
grep $vg2 out2
grep $vg3 out3
grep $vg4 out4
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out1
grep "$SERIAL1" out2
cat "$DF"
grep "$PVID1" "$DF" |tee out1
grep "$PVID2" "$DF" |tee out2
grep "$PVID3" "$DF" |tee out3
grep "$PVID4" "$DF" |tee out4
grep "$dev1" out1
grep "$SERIAL1" out1
grep "$dev2" out2
grep "$SERIAL1" out2
grep "$dev3" out3
grep "$dev4" out4
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# two pvs with duplicate serial and stale devname, one pv with unique serial and stale pvid
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL3" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1"
vgcreate $vg2 "$dev2"
vgcreate $vg3 "$dev3"
cp "$DF" "$ORIG"
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
cat "$DF"
pvs -o+uuid,deviceid "${devs[@]}" || true
cp "$ORIG" orig
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=$dev4|" orig > tmp1
sed -e "s|DEVNAME=$dev2|DEVNAME=$dev1|" tmp1 > tmp2
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
sed -e "s|PVID=$dev3|PVID=bad14onBxSiv4dot0GRDPtrWqOlr1bad|" tmp2 > "$DF"
cat "$DF"
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" > out || true
cat out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$dev3" out |tee out3
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$OPVID3" out3
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
grep $vg1 out1
grep $vg2 out2
grep $vg3 out3
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
grep "$SERIAL1" out1
grep "$SERIAL1" out2
grep "$SERIAL3" out3
cat "$DF"
grep "$PVID1" "$DF" |tee out1
grep "$PVID2" "$DF" |tee out2
grep "$PVID3" "$DF" |tee out3
grep "$dev1" out1
grep "$SERIAL1" out1
grep "$dev2" out2
grep "$SERIAL1" out2
grep "$dev3" out3
grep "$SERIAL3" out3
device_id: handle duplicate serial numbers Handle multiple devices using the same serial number as their device id. After matching devices to devices file entries, if there is a discrepency between the ondisk PVID and the devices file PVID, then rematch devices to devices file entries using PVID, looking at all disks on the system with the same serial number.
2022-11-01 00:14:01 +03:00
device_id: fix segfault verifying serial for non-pv The recent change that verifies sys_serial system.devices entries using the PVID did not exclude non-PV devices from being checked. The verification code would attempt to use du->pvid which was null for the non-PVs causing a segfault.
2022-12-02 20:59:09 +03:00
# non-PV devices
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "${devs[@]}"
device_id: fix segfault verifying serial for non-pv The recent change that verifies sys_serial system.devices entries using the PVID did not exclude non-PV devices from being checked. The verification code would attempt to use du->pvid which was null for the non-PVs causing a segfault.
2022-12-02 20:59:09 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL2" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
echo "$SERIAL4" > "$SYS_DIR/dev/block/$MAJOR4:$MINOR4/device/serial"
device_id: fix segfault verifying serial for non-pv The recent change that verifies sys_serial system.devices entries using the PVID did not exclude non-PV devices from being checked. The verification code would attempt to use du->pvid which was null for the non-PVs causing a segfault.
2022-12-02 20:59:09 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
rm "$DF"
touch "$DF"
vgcreate $vg4 "$dev4"
device_id: fix segfault verifying serial for non-pv The recent change that verifies sys_serial system.devices entries using the PVID did not exclude non-PV devices from being checked. The verification code would attempt to use du->pvid which was null for the non-PVs causing a segfault.
2022-12-02 20:59:09 +03:00
lvmdevices --adddev "$dev1"
lvmdevices --adddev "$dev2"
lvmdevices --adddev "$dev3"
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
cat "$DF"
grep "$dev1" "$DF" |tee out1
grep "$dev2" "$DF" |tee out2
grep "$dev3" "$DF" |tee out3
grep "$dev4" "$DF" |tee out4
grep "$SERIAL1" out1
grep "$SERIAL2" out2
grep "$SERIAL2" out3
grep "$SERIAL4" out4
pvs "${devs[@]}" > out || true
cat out
grep "$dev4" out
not grep "$dev1" out
not grep "$dev2" out
not grep "$dev3" out
pvcreate "$dev1"
pvs "${devs[@]}" > out || true
cat out
grep "$dev1" out
grep "$dev4" out
not grep "$dev2" out
not grep "$dev3" out
pvcreate "$dev2"
pvs "${devs[@]}" > out || true
cat out
grep "$dev1" out
grep "$dev4" out
grep "$dev2" out
not grep "$dev3" out
pvcreate "$dev3"
pvs "${devs[@]}" |tee out
grep "$dev1" out
grep "$dev4" out
grep "$dev2" out
grep "$dev3" out
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
OPVID3=$(echo $(pvs --noheading -o uuid "$dev3") )
OPVID4=$(echo $(pvs --noheading -o uuid "$dev4") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
PVID3=${OPVID3//-/}
PVID4=${OPVID4//-/}
grep "$dev1" "$DF" |tee out1
grep "$dev2" "$DF" |tee out2
grep "$dev3" "$DF" |tee out3
grep "$dev4" "$DF" |tee out4
grep "$PVID1" out1
grep "$PVID2" out2
grep "$PVID3" out3
grep "$PVID4" out4
vgcreate $vg2 "$dev2" "$dev3"
device_id: fix segfault verifying serial for non-pv The recent change that verifies sys_serial system.devices entries using the PVID did not exclude non-PV devices from being checked. The verification code would attempt to use du->pvid which was null for the non-PVs causing a segfault.
2022-12-02 20:59:09 +03:00
vgs | grep $vg2
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
# 3 devs with duplicate serial, 2 pvs with stale devnames, 1 non-pv device
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
aux wipefs_a "$dev1" "$dev2" "$dev3"
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR1:$MINOR1/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR2:$MINOR2/device/serial"
echo "$SERIAL1" > "$SYS_DIR/dev/block/$MAJOR3:$MINOR3/device/serial"
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
rm "$DF"
touch "$DF"
vgcreate $vg1 "$dev1" "$dev2"
lvmdevices --adddev "$dev3"
cat "$DF"
cp "$DF" "$ORIG"
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
OPVID1=$(echo $(pvs --noheading -o uuid "$dev1") )
OPVID2=$(echo $(pvs --noheading -o uuid "$dev2") )
PVID1=${OPVID1//-/}
PVID2=${OPVID2//-/}
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" || true
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
sed -e "s|DEVNAME=$dev1|DEVNAME=tmp|" "$ORIG" > tmp1
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
sed -e "s|DEVNAME=$dev2|DEVNAME=$dev1|" tmp1 > tmp2
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
sed -e "s|DEVNAME=tmp|DEVNAME=$dev2|" tmp2 > "$DF"
cat "$DF"
device_id: fix handling of non-PV with duplicate serial number Fix in the code that matches devices to system.devices entries when the devices have the same serial number. A non-PV device in system.devices has no pvid value, and the code was segfaulting when checking the null pvid value.
2023-06-08 20:24:05 +03:00
# pvs should report the correct info and fix the DF
tests: avoid using /test dir Keep using test directory for created files. Trap errors and remove brd in this case. Use some shell builtins to reduce fork count. Use "$VAR". Run 'pvs' with devlist (so not acceing other system devices).
2023-07-14 23:05:27 +03:00
pvs -o+uuid,deviceid "${devs[@]}" > out || true
cat out
grep "$dev1" out |tee out1
grep "$dev2" out |tee out2
grep "$OPVID1" out1
grep "$OPVID2" out2
grep "$SERIAL1" out1
grep "$SERIAL1" out2
Copy Permalink