shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-03-21 14:50:12 +03:00
Code
systemd-stable/test/units/testsuite-58.sh

1156 lines
38 KiB
Bash
Raw Permalink Normal View History

test: add test for new repart features
2021-04-19 17:30:33 +02:00
#!/usr/bin/env bash
tests: add spdx headers to scripts and Makefiles
2021-10-17 18:13:06 +02:00
# SPDX-License-Identifier: LGPL-2.1-or-later
test: add test for new repart features
2021-04-19 17:30:33 +02:00
set -eux
TEST-58: adjust whitespace and enable pipefail
2021-04-20 17:07:41 +02:00
set -o pipefail
test: add test for new repart features
2021-04-19 17:30:33 +02:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas() {
declare userid=$1
shift
test: use setpriv instead of su for user switch from root systemd-repart needs to find mkfs.ext4 for the test. This is located in the directory /usr/sbin on openSUSE Tumbleweed. But since the variable ALWAYS_SET_PATH in /etc/login.defs is set to yes, su re-initializes the $PATH variable and removes /usr/sbin. Hence, mkfs.ext4 is not found and the test fails. Using setpriv instead of su fixes this issue and is more appropriate to do the switch user task from root. [zjs: move setpriv to $BASICTOOLS and force-push to retrigger CI] (cherry picked from commit c7bf1959d7580e1b7e918b75f852b3bf3fb6eb3c)
2023-03-14 15:21:29 +01:00
XDG_RUNTIME_DIR=/run/user/"$(id -u "$userid")" setpriv --reuid="$userid" --init-groups "$@"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
}
tests: drop unnecessary redirection of stderr command -v doesn't print anything to stderr, let's use the canonical form with just >/dev/null. (cherry picked from commit e80444729fbfc05d4b22e775072165eba72fae72)
2023-05-29 12:28:34 +02:00
if ! command -v systemd-repart >/dev/null; then
TEST-58: exit immediately if systemd-repart is not available Debian disables systemd-repart at config time.
2021-04-21 23:37:57 +02:00
echo "no systemd-repart" >/skipped
exit 0
fi
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# shellcheck source=test/units/assert.sh
. "$(dirname "$0")"/assert.sh
test: add test for new repart features
2021-04-19 17:30:33 +02:00
export SYSTEMD_LOG_LEVEL=debug
export PAGER=cat
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
# Disable use of special glyphs such as →
export SYSTEMD_UTF8=0
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
seed=750b6cd5c4ae4012a15e7be3c29e6a47
test: make TEST-58-REPART support nspawn
2022-08-20 04:59:03 +09:00
if ! systemd-detect-virt --quiet --container; then
test-58-repart: use udevadm control instead of creating service drop-in
2022-08-27 00:51:28 +09:00
udevadm control --log-level debug
test: make TEST-58-REPART support nspawn
2022-08-20 04:59:03 +09:00
fi
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
machine="$(uname -m)"
if [ "${machine}" = "x86_64" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
root_uuid=60F33797-1D71-4DCB-AA6F-20564F036CD0
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=73A4CCD2-EAF5-44DA-A366-F99188210FDC
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=8484680C-9521-48C6-9C11-B0720656F69E
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
usr_uuid=7E3369DD-D653-4513-ADF5-B993A9F20C16
architecture="x86-64"
elif [ "${machine}" = "i386" ] || [ "${machine}" = "i686" ] || [ "${machine}" = "x86" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=44479540-F297-41B2-9AF7-D131D5F0458A
root_uuid=02B4253F-29A4-404E-8972-1669D3B03C87
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=268E0FD3-B468-4806-A823-E533FE9BB9CC
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=75250D76-8CC6-458E-BD66-BD47CC81A812
usr_uuid=7B42FFB0-B0E1-4395-B20B-C78F4A571648
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="x86"
elif [ "${machine}" = "aarch64" ] || [ "${machine}" = "aarch64_be" ] || [ "${machine}" = "armv8b" ] || [ "${machine}" = "armv8l" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=B921B045-1DF0-41C3-AF44-4C6F280D3FAE
root_uuid=055D0227-53A6-4033-85C3-9A5973EFF483
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=F7DBBE48-8FD0-4833-8411-AA34E7C8E60A
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=B0E01050-EE5F-4390-949A-9101B17104E9
usr_uuid=FCE3C75E-D6A4-44C0-87F0-4C105183FB1F
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="arm64"
elif [ "${machine}" = "arm" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=69DAD710-2CE4-4E3C-B16C-21A1D49ABED3
root_uuid=567DA89E-8DE2-4499-8D10-18F212DFF034
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=813ECFE5-4C89-4193-8A52-437493F2F96E
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=7D0359A3-02B3-4F0A-865C-654403E70625
usr_uuid=71E93DC2-5073-42CB-8A84-A354E64D8966
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="arm"
elif [ "${machine}" = "loongarch64" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=77055800-792C-4F94-B39A-98C91B762BB6
root_uuid=D8EFC2D2-0133-41E4-BDCB-3B9F4CFDDDE8
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=36499F9E-0688-40C1-A746-EA8FD9543C56
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=E611C702-575C-4CBE-9A46-434FA0BF7E3F
usr_uuid=031FFA75-00BB-49B6-A70D-911D2D82A5B7
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="loongarch64"
elif [ "${machine}" = "ia64" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=993D8D3D-F80E-4225-855A-9DAF8ED7EA97
root_uuid=DCF33449-0896-4EA9-BC24-7D58AEEF522D
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=C2A6CAB7-ABEA-4FBA-8C48-CB4C52E6CA38
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=4301D2A6-4E3B-4B2A-BB94-9E0B2C4225EA
usr_uuid=BC2BCCE7-80D6-449A-85CC-637424CE5241
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="ia64"
elif [ "${machine}" = "s390x" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=5EEAD9A9-FE09-4A1E-A1D7-520D00531306
root_uuid=7EBE0C85-E27E-48EC-B164-F4807606232E
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=2A074E1C-2A19-4094-A0C2-24B1A5D52FCB
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=8A4F5770-50AA-4ED3-874A-99B710DB6FEA
usr_uuid=51171D30-35CF-4A49-B8B5-9478B9B796A5
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="s390x"
elif [ "${machine}" = "ppc64le" ]; then
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
root_guid=C31C45E6-3F39-412E-80FB-4809C4980599
root_uuid=061E67A1-092F-482F-8150-B525D50D6654
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
root_uuid2=A6687CEF-4E4F-44E7-90B3-CDA52EA81739
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
usr_guid=15BB03AF-77E7-4D4A-B12B-C0D084F7491C
usr_uuid=C0D0823B-8040-4C7C-A629-026248E297FB
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
architecture="ppc64-le"
else
echo "Unexpected uname -m: ${machine} in testsuite-58.sh, please fix me"
exit 1
fi
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
test_basic() {
local defs imgs output
local loop volume
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
# 1. create an empty image
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --empty=create \
--size=1G \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 2097118"
# 2. Testing with root, root2, home, and swap
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=root
EOF
ln -s root.conf "$defs/root2.conf"
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/home.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=home
Label=home-first
Label=home-always-too-long-xxxxxxxxxxxxxx-%v
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/swap.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=swap
SizeMaxBytes=64M
PaddingMinBytes=92M
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--dry-run=no \
--seed="$seed" \
--include-partitions=home,swap \
"$imgs/zzz"
repart: Add integration test for --include/--exclude-partitions
2022-11-11 14:26:45 +01:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 2097118
repart: Add --skip-partitions= --include-partitions and --exclude-partitions now fully exclude partitions from repart. Whenever a partition type is excluded, we don't take any partitions of that type into account at all when running systemd-repart. --skip-partitions= is introduced to do what --exclude-partitions did previously. Any skipped partitions are taken into acount when doing size calculations, but are not yet populated. Why do we need both concepts? Exclusion is needed so that we can use shared repart definitions to generate bootable and non-bootable images. When generating a non-bootable image, we use --exclude-partitions to exclude the ESP partition. Skipping is needed so that we can populate the root partition while skipping the ESP partition, get the roothash of the root partition, use that to generate a UKI, and finally populate the ESP partition with the UKI included.
2022-11-22 14:27:30 +01:00
$imgs/zzz1 : start= 2048, size= 1775576, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\""
repart: Add integration test for --include/--exclude-partitions
2022-11-11 14:26:45 +01:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--dry-run=no \
--seed="$seed" \
repart: Add --skip-partitions= --include-partitions and --exclude-partitions now fully exclude partitions from repart. Whenever a partition type is excluded, we don't take any partitions of that type into account at all when running systemd-repart. --skip-partitions= is introduced to do what --exclude-partitions did previously. Any skipped partitions are taken into acount when doing size calculations, but are not yet populated. Why do we need both concepts? Exclusion is needed so that we can use shared repart definitions to generate bootable and non-bootable images. When generating a non-bootable image, we use --exclude-partitions to exclude the ESP partition. Skipping is needed so that we can populate the root partition while skipping the ESP partition, get the roothash of the root partition, use that to generate a UKI, and finally populate the ESP partition with the UKI included.
2022-11-22 14:27:30 +01:00
--empty=force \
repart: Rename --skip-partitions to --defer-partitions Defer is better because it indicates that we still intend to populate these partitions later.
2022-12-13 18:14:43 +00:00
--defer-partitions=home,root \
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
"$imgs/zzz"
repart: Add integration test for --include/--exclude-partitions
2022-11-11 14:26:45 +01:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 2097118
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\""
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--dry-run=no \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 2097118
$imgs/zzz1 : start= 2048, size= 591856, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 593904, size= 591856, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"
$imgs/zzz3 : start= 1185760, size= 591864, type=${root_guid}, uuid=${root_uuid2}, name=\"root-${architecture}-2\", attrs=\"GUID:59\"
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\""
# 3. Testing with root, root2, home, swap, and another partition
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/swap.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=swap
SizeMaxBytes=64M
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/extra.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=linux-generic
Label=custom_label
UUID=a0a1a2a3a4a5a6a7a8a9aaabacadaeaf
EOF
echo "Label=ignored_label" >>"$defs/home.conf"
echo "UUID=b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" >>"$defs/home.conf"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--dry-run=no \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 2097118
$imgs/zzz1 : start= 2048, size= 591856, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 593904, size= 591856, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"
$imgs/zzz3 : start= 1185760, size= 591864, type=${root_guid}, uuid=${root_uuid2}, name=\"root-${architecture}-2\", attrs=\"GUID:59\"
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\"
$imgs/zzz5 : start= 1908696, size= 188416, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=A0A1A2A3-A4A5-A6A7-A8A9-AAABACADAEAF, name=\"custom_label\""
# 4. Resizing to 2G
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--size=2G \
--dry-run=no \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 4194270
$imgs/zzz1 : start= 2048, size= 591856, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 593904, size= 591856, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"
$imgs/zzz3 : start= 1185760, size= 591864, type=${root_guid}, uuid=${root_uuid2}, name=\"root-${architecture}-2\", attrs=\"GUID:59\"
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\"
$imgs/zzz5 : start= 1908696, size= 2285568, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=A0A1A2A3-A4A5-A6A7-A8A9-AAABACADAEAF, name=\"custom_label\""
# 5. Testing with root, root2, home, swap, another partition, and partition copy
dd if=/dev/urandom of="$imgs/block-copy" bs=4096 count=10240
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/extra2.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=linux-generic
Label=block-copy
UUID=2a1d97e1d0a346cca26eadc643926617
CopyBlocks=$imgs/block-copy
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--size=3G \
--dry-run=no \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 6291422
$imgs/zzz1 : start= 2048, size= 591856, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 593904, size= 591856, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"
$imgs/zzz3 : start= 1185760, size= 591864, type=${root_guid}, uuid=${root_uuid2}, name=\"root-${architecture}-2\", attrs=\"GUID:59\"
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\"
$imgs/zzz5 : start= 1908696, size= 2285568, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=A0A1A2A3-A4A5-A6A7-A8A9-AAABACADAEAF, name=\"custom_label\"
$imgs/zzz6 : start= 4194264, size= 2097152, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=2A1D97E1-D0A3-46CC-A26E-ADC643926617, name=\"block-copy\""
cmp --bytes=$((4096*10240)) --ignore-initial=0:$((512*4194264)) "$imgs/block-copy" "$imgs/zzz"
# 6. Testing Format=/Encrypt=/CopyFiles=
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/extra3.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=linux-generic
Label=luks-format-copy
UUID=7b93d1f2-595d-4ce3-b0b9-837fbd9e63b0
Format=ext4
Encrypt=yes
CopyFiles=$defs:/def
SizeMinBytes=48M
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--size=auto \
--dry-run=no \
--seed="$seed" \
"$imgs/zzz"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
output=$(sfdisk -d "$imgs/zzz" | grep -v -e 'sector-size' -e '^$')
assert_eq "$output" "label: gpt
label-id: 1D2CE291-7CCE-4F7D-BC83-FDB49AD74EBD
device: $imgs/zzz
unit: sectors
first-lba: 2048
last-lba: 6389726
$imgs/zzz1 : start= 2048, size= 591856, type=933AC7E1-2EB4-4F13-B844-0E14E2AEF915, uuid=4980595D-D74A-483A-AA9E-9903879A0EE5, name=\"home-first\", attrs=\"GUID:59\"
$imgs/zzz2 : start= 593904, size= 591856, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"
$imgs/zzz3 : start= 1185760, size= 591864, type=${root_guid}, uuid=${root_uuid2}, name=\"root-${architecture}-2\", attrs=\"GUID:59\"
$imgs/zzz4 : start= 1777624, size= 131072, type=0657FD6D-A4AB-43C4-84E5-0933C84B4F4F, uuid=78C92DB8-3D2B-4823-B0DC-792B78F66F1E, name=\"swap\"
$imgs/zzz5 : start= 1908696, size= 2285568, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=A0A1A2A3-A4A5-A6A7-A8A9-AAABACADAEAF, name=\"custom_label\"
$imgs/zzz6 : start= 4194264, size= 2097152, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=2A1D97E1-D0A3-46CC-A26E-ADC643926617, name=\"block-copy\"
$imgs/zzz7 : start= 6291416, size= 98304, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=7B93D1F2-595D-4CE3-B0B9-837FBD9E63B0, name=\"luks-format-copy\""
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
if systemd-detect-virt --quiet --container; then
echo "Skipping encrypt mount tests in container."
return
fi
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
loop="$(losetup -P --show --find "$imgs/zzz")"
test: wait for partition processed by udevd Fixes #32695. (cherry picked from commit 71f04871739892db2cdbb6a746360fb243f24dc6) (cherry picked from commit 8318972184d1f6a382fc6fb28f81a5d992fe145b) (cherry picked from commit e62ecc65116fb768afb26de7c2cb48025caaf86e)
2024-05-17 10:12:25 +09:00
udevadm wait --timeout 60 --settle "${loop:?}p7"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
volume="test-repart-$RANDOM"
touch "$imgs/empty-password"
cryptsetup open --type=luks2 --key-file="$imgs/empty-password" "${loop}p7" "$volume"
mkdir -p "$imgs/mount"
mount -t ext4 "/dev/mapper/$volume" "$imgs/mount"
# Use deferred closing on the mapper and autoclear on the loop, so they are cleaned up on umount
cryptsetup close --deferred "$volume"
losetup -d "$loop"
diff -r "$imgs/mount/def" "$defs" >/dev/null
umount "$imgs/mount"
}
test_dropin() {
local defs imgs output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=swap
SizeMaxBytes=64M
UUID=837c3d67-21b3-478e-be82-7e7f83bf96d3
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser mkdir -p "$defs/root.conf.d"
runas testuser tee "$defs/root.conf.d/override1.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Label=label1
SizeMaxBytes=32M
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf.d/override2.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Label=label2
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
output=$(runas testuser systemd-repart --definitions="$defs" \
--empty=create \
--size=100M \
--json=pretty \
"$imgs/zzz")
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
TEST-58-REPART: reverse order of diff args I expect the test output to be the second argument, so we're diffing "expected" and "output", not the other way around. I noticed this when working on https://github.com/systemd/systemd/pull/33081. (cherry picked from commit 6bb3ea655d08c0602c99ccd2a580ba102fd19114) (cherry picked from commit 9663bb74100dd79c1e4e9c6b2377ea1b817ddee5) (cherry picked from commit 5469bc61185163119bec209612e0a72381ba232c) (cherry picked from commit b8b652d11f2c49be5a841fe61c28e038ea1ea04a)
2024-05-30 11:33:20 +02:00
diff -u - <<EOF <(echo "$output")
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[
{
"type" : "swap",
"label" : "label2",
"uuid" : "837c3d67-21b3-478e-be82-7e7f83bf96d3",
format-table: add field type TABLE_PATH_BASENAME This is just like TABLE_PATH, but only shows the basename in regular tabular output. This is useful in systemd-repart for example
2022-12-21 17:06:14 +01:00
"file" : "$defs/root.conf",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"node" : "$imgs/zzz1",
"offset" : 1048576,
"old_size" : 0,
"raw_size" : 33554432,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"size" : "-> 32.0M",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"old_padding" : 0,
"raw_padding" : 0,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"padding" : "-> 0B",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"activity" : "create",
"drop-in_files" : [
"$defs/root.conf.d/override1.conf",
"$defs/root.conf.d/override2.conf"
]
}
]
EOF
}
test_multiple_definitions() {
local defs imgs output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser mkdir -p "$defs/1"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/1/root1.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=swap
SizeMaxBytes=32M
UUID=7b93d1f2-595d-4ce3-b0b9-837fbd9e63b0
Label=label1
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser mkdir -p "$defs/2"
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/2/root2.conf" <<EOF
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[Partition]
Type=swap
SizeMaxBytes=32M
UUID=837c3d67-21b3-478e-be82-7e7f83bf96d3
Label=label2
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
output=$(runas testuser systemd-repart --definitions="$defs/1" \
--definitions="$defs/2" \
--empty=create \
--size=100M \
--json=pretty \
"$imgs/zzz")
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
TEST-58-REPART: reverse order of diff args I expect the test output to be the second argument, so we're diffing "expected" and "output", not the other way around. I noticed this when working on https://github.com/systemd/systemd/pull/33081. (cherry picked from commit 6bb3ea655d08c0602c99ccd2a580ba102fd19114) (cherry picked from commit 9663bb74100dd79c1e4e9c6b2377ea1b817ddee5) (cherry picked from commit 5469bc61185163119bec209612e0a72381ba232c) (cherry picked from commit b8b652d11f2c49be5a841fe61c28e038ea1ea04a)
2024-05-30 11:33:20 +02:00
diff -u - <<EOF <(echo "$output")
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
[
{
"type" : "swap",
"label" : "label1",
"uuid" : "7b93d1f2-595d-4ce3-b0b9-837fbd9e63b0",
format-table: add field type TABLE_PATH_BASENAME This is just like TABLE_PATH, but only shows the basename in regular tabular output. This is useful in systemd-repart for example
2022-12-21 17:06:14 +01:00
"file" : "$defs/1/root1.conf",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"node" : "$imgs/zzz1",
"offset" : 1048576,
"old_size" : 0,
"raw_size" : 33554432,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"size" : "-> 32.0M",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"old_padding" : 0,
"raw_padding" : 0,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"padding" : "-> 0B",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"activity" : "create"
},
{
"type" : "swap",
"label" : "label2",
"uuid" : "837c3d67-21b3-478e-be82-7e7f83bf96d3",
format-table: add field type TABLE_PATH_BASENAME This is just like TABLE_PATH, but only shows the basename in regular tabular output. This is useful in systemd-repart for example
2022-12-21 17:06:14 +01:00
"file" : "$defs/2/root2.conf",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"node" : "$imgs/zzz2",
"offset" : 34603008,
"old_size" : 0,
"raw_size" : 33554432,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"size" : "-> 32.0M",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"old_padding" : 0,
"raw_padding" : 0,
locale: honour new env var $SYSTEMD_UTF8= This is useful to force off fancy unicode glyph use (i.e. use "->" instead of "→"), which is useful in tests where locales might be missing, and thus control via $LC_CTYPE is not reliable. Use this in TEST-58, to ensure the output checks we do aren't confused by missing these glyphs being unicode or not.
2022-11-10 17:18:50 +01:00
"padding" : "-> 0B",
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
"activity" : "create"
}
]
EOF
}
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
test_copy_blocks() {
local defs imgs output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
test: add test for new repart features
2021-04-19 17:30:33 +02:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# First, create a disk image and verify its in order
test: add test for new repart features
2021-04-19 17:30:33 +02:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/esp.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
Type=esp
SizeMinBytes=10M
Format=vfat
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/usr.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
Type=usr-${architecture}
test: add test for new repart features
2021-04-19 17:30:33 +02:00
SizeMinBytes=10M
Format=ext4
ReadOnly=yes
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
Type=root-${architecture}
test: add test for new repart features
2021-04-19 17:30:33 +02:00
SizeMinBytes=10M
Format=ext4
MakeDirectories=/usr /efi
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--empty=create \
--size=auto \
--seed="$seed" \
"$imgs/zzz"
test: add test for new repart features
2021-04-19 17:30:33 +02:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
output=$(sfdisk --dump "$imgs/zzz")
test: add test for new repart features
2021-04-19 17:30:33 +02:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
assert_in "$imgs/zzz1 : start= 2048, size= 20480, type=C12A7328-F81F-11D2-BA4B-00A0C93EC93B, uuid=39107B09-615D-48FB-BA37-C663885FCE67, name=\"esp\"" "$output"
assert_in "$imgs/zzz2 : start= 22528, size= 20480, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"" "$output"
assert_in "$imgs/zzz3 : start= 43008, size= 20480, type=${usr_guid}, uuid=${usr_uuid}, name=\"usr-${architecture}\", attrs=\"GUID:60\"" "$output"
test: add test for new repart features
2021-04-19 17:30:33 +02:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
if systemd-detect-virt --quiet --container; then
echo "Skipping second part of copy blocks tests in container."
return
fi
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# Then, create another image with CopyBlocks=auto
test: add test for new repart features
2021-04-19 17:30:33 +02:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/esp.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
Type=esp
CopyBlocks=auto
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/usr.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
Type=usr-${architecture}
test: add test for new repart features
2021-04-19 17:30:33 +02:00
ReadOnly=yes
CopyBlocks=auto
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test: add test for new repart features
2021-04-19 17:30:33 +02:00
[Partition]
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
Type=root-${architecture}
test: add test for new repart features
2021-04-19 17:30:33 +02:00
CopyBlocks=auto
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
# --image needs root privileges so skip runas testuser here.
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
systemd-repart --definitions="$defs" \
--empty=create \
--size=auto \
--seed="$seed" \
--image="$imgs/zzz" \
"$imgs/yyy"
test: add test for new repart features
2021-04-19 17:30:33 +02:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
cmp "$imgs/zzz" "$imgs/yyy"
}
test: add test for new repart features
2021-04-19 17:30:33 +02:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
test_unaligned_partition() {
local defs imgs output
test: add test for new repart features
2021-04-19 17:30:33 +02:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# Operate on an image with unaligned partition.
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
[Partition]
test: do not assume x86-64 arch in TEST-58-REPART
2022-01-12 22:38:22 +00:00
Type=root-${architecture}
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 10g "$imgs/unaligned"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
sfdisk "$imgs/unaligned" <<EOF
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
label: gpt
start=2048, size=69044
start=71092, size=3591848
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
"$imgs/unaligned"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
output=$(sfdisk --dump "$imgs/unaligned")
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
assert_in "$imgs/unaligned1 : start= 2048, size= 69044," "$output"
assert_in "$imgs/unaligned2 : start= 71092, size= 3591848," "$output"
assert_in "$imgs/unaligned3 : start= 3662944, size= 17308536, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"" "$output"
}
test_issue_21817() {
local defs imgs output
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# testcase for #21817
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
test: extend repart test suite to test for unaligned partitions
2021-11-09 16:53:11 +01:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/test.conf" <<EOF
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
[Partition]
Type=root
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 100m "$imgs/21817.img"
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
sfdisk "$imgs/21817.img" <<EOF
test: drop unnecessary use of loop device To avoid inferences with udevd.
2022-04-07 01:39:20 +09:00
label: gpt
size=50M, type=${root_guid}
,
EOF
test: add a test case for issue #21817
2021-12-20 23:47:52 +09:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --pretty=yes \
--definitions "$imgs" \
--seed="$seed" \
--dry-run=no \
"$imgs/21817.img"
test: add a test case for issue #21817
2021-12-20 23:47:52 +09:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
output=$(sfdisk --dump "$imgs/21817.img")
test: add a test case for issue #21817
2021-12-20 23:47:52 +09:00
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
assert_in "$imgs/21817.img1 : start= 2048, size= 102400, type=${root_guid}," "$output"
# Accept both unpadded (pre-v2.38 util-linux) and padded (v2.38+ util-linux) sizes
assert_in "$imgs/21817.img2 : start= 104448, size= (100319| 98304)," "$output"
}
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
test_issue_24553() {
local defs imgs output
# testcase for #24553
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
[Partition]
Type=root
SizeMinBytes=10G
SizeMaxBytes=120G
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$imgs/partscript" <<EOF
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
label: gpt
label-id: C9FFE979-A415-C449-B729-78C7AA664B10
unit: sectors
first-lba: 40
start=40, size=524288, type=C12A7328-F81F-11D2-BA4B-00A0C93EC93B, uuid=F2E89C8A-DC5D-4C4C-A29C-6CFB643B74FD, name="ESP System Partition"
start=524328, size=14848000, type=${root_guid}, uuid=${root_uuid}, name="root-${architecture}"
EOF
# 1. Operate on a small image compared with SizeMinBytes=.
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 8g "$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
sfdisk "$imgs/zzz" <"$imgs/partscript"
# This should fail, but not trigger assertions.
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
assert_rc 1 runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
"$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
output=$(sfdisk --dump "$imgs/zzz")
assert_in "$imgs/zzz2 : start= 524328, size= 14848000, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\"" "$output"
# 2. Operate on an larger image compared with SizeMinBytes=.
rm -f "$imgs/zzz"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 12g "$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
sfdisk "$imgs/zzz" <"$imgs/partscript"
# This should succeed.
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
"$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
output=$(sfdisk --dump "$imgs/zzz")
assert_in "$imgs/zzz2 : start= 524328, size= 24641456, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\"" "$output"
# 3. Multiple partitions with Priority= (small disk)
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
[Partition]
Type=root
SizeMinBytes=10G
SizeMaxBytes=120G
Priority=100
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/usr.conf" <<EOF
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
[Partition]
Type=usr
SizeMinBytes=10M
Priority=10
EOF
rm -f "$imgs/zzz"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 8g "$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
sfdisk "$imgs/zzz" <"$imgs/partscript"
# This should also succeed, but root is not extended.
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
"$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
output=$(sfdisk --dump "$imgs/zzz")
assert_in "$imgs/zzz2 : start= 524328, size= 14848000, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\"" "$output"
assert_in "$imgs/zzz3 : start= 15372328, size= 1404848, type=${usr_guid}, uuid=${usr_uuid}, name=\"usr-${architecture}\", attrs=\"GUID:59\"" "$output"
# 4. Multiple partitions with Priority= (large disk)
rm -f "$imgs/zzz"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser truncate -s 12g "$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
sfdisk "$imgs/zzz" <"$imgs/partscript"
# This should also succeed, and root is extended.
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
"$imgs/zzz"
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
output=$(sfdisk --dump "$imgs/zzz")
assert_in "$imgs/zzz2 : start= 524328, size= 20971520, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\"" "$output"
assert_in "$imgs/zzz3 : start= 21495848, size= 3669936, type=${usr_guid}, uuid=${usr_uuid}, name=\"usr-${architecture}\", attrs=\"GUID:59\"" "$output"
}
repart: Add support for setting a partition's UUID to zero This is useful when we need to fill in the UUID later, such as when using verity partitions.
2022-09-04 18:53:25 +02:00
test_zero_uuid() {
local defs imgs output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
repart: Add support for setting a partition's UUID to zero This is useful when we need to fill in the UUID later, such as when using verity partitions.
2022-09-04 18:53:25 +02:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
# Test image with zero UUID.
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/root.conf" <<EOF
repart: Add support for setting a partition's UUID to zero This is useful when we need to fill in the UUID later, such as when using verity partitions.
2022-09-04 18:53:25 +02:00
[Partition]
Type=root-${architecture}
UUID=null
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=create \
--size=auto \
"$imgs/zero"
repart: Add support for setting a partition's UUID to zero This is useful when we need to fill in the UUID later, such as when using verity partitions.
2022-09-04 18:53:25 +02:00
output=$(sfdisk --dump "$imgs/zero")
assert_in "$imgs/zero1 : start= 2048, size= 20480, type=${root_guid}, uuid=00000000-0000-0000-0000-000000000000" "$output"
}
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
test_verity() {
local defs imgs output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/verity-data.conf" <<EOF
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
[Partition]
Type=root-${architecture}
CopyFiles=${defs}
Verity=data
VerityMatchKey=root
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/verity-hash.conf" <<EOF
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
[Partition]
Type=root-${architecture}-verity
Verity=hash
VerityMatchKey=root
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/verity-sig.conf" <<EOF
repart: Add support for generating verity sig partitions
2022-09-11 10:49:24 +02:00
[Partition]
Type=root-${architecture}-verity-sig
Verity=signature
VerityMatchKey=root
EOF
# Unfortunately OpenSSL insists on reading some config file, hence provide one with mostly placeholder contents
test: drop whitespace after shell redirection operators (The one case that is left unchanged is '< <(subcommand)'.) This way, the style with no gap was already dominant. This way, the reader immediately knows that ' < ' is a comparison operator and ' << ' is a shift. In a few cases, replace custom EOF replacement by just EOF. There is no point in using someting like "_EOL" unless "EOF" appears in the text.
2023-02-05 21:41:24 +01:00
runas testuser tee >"$defs/verity.openssl.cnf" <<EOF
repart: Add support for generating verity sig partitions
2022-09-11 10:49:24 +02:00
[ req ]
prompt = no
distinguished_name = req_distinguished_name
[ req_distinguished_name ]
C = DE
ST = Test State
L = Test Locality
O = Org Name
OU = Org Unit Name
CN = Common Name
emailAddress = test@email.com
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
runas testuser openssl req -config "$defs/verity.openssl.cnf" \
-new -x509 \
-newkey rsa:1024 \
-keyout "$defs/verity.key" \
-out "$defs/verity.crt" \
-days 365 \
-nodes
repart: Add support for generating verity sig partitions
2022-09-11 10:49:24 +02:00
mkdir -p /run/verity.d
ln -s "$defs/verity.crt" /run/verity.d/ok.crt
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
output=$(runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=create \
--size=auto \
--json=pretty \
--private-key="$defs/verity.key" \
--certificate="$defs/verity.crt" \
"$imgs/verity")
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
TEST-58: remove whitespace between redirection operator and its argument (cherry picked from commit 730ab2cc23a8de4bd9c00e7a49e3864967cdb1fa)
2023-05-29 20:54:44 +02:00
drh=$(jq -r ".[] | select(.type == \"root-${architecture}\") | .roothash" <<<"$output")
hrh=$(jq -r ".[] | select(.type == \"root-${architecture}-verity\") | .roothash" <<<"$output")
srh=$(jq -r ".[] | select(.type == \"root-${architecture}-verity-sig\") | .roothash" <<<"$output")
repart: Add roothash to output of all verity siblings This can be used to match verity partitions together using the repart JSON output.
2023-01-25 15:56:30 +01:00
assert_eq "$drh" "$hrh"
assert_eq "$hrh" "$srh"
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
test: add quick test for ensuring image UUID is deterministic based on the seed passed to repart
2022-11-10 17:33:31 +01:00
# Check that we can dissect, mount and unmount a repart verity image. (and that the image UUID is deterministic)
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
if systemd-detect-virt --quiet --container; then
echo "Skipping verity test dissect part in container."
return
fi
repart: Add roothash to output of all verity siblings This can be used to match verity partitions together using the repart JSON output.
2023-01-25 15:56:30 +01:00
systemd-dissect "$imgs/verity" --root-hash "$drh"
systemd-dissect "$imgs/verity" --root-hash "$drh" --json=short | grep -q '"imageUuid":"1d2ce291-7cce-4f7d-bc83-fdb49ad74ebd"'
systemd-dissect "$imgs/verity" --root-hash "$drh" -M "$imgs/mnt"
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
systemd-dissect -U "$imgs/mnt"
}
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
test_issue_24786() {
local defs imgs root output
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
defs="$(runas testuser mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
root="$(runas testuser mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs' '$root'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser touch "$root/abc"
runas testuser mkdir "$root/usr"
runas testuser touch "$root/usr/def"
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/00-root.conf" <<EOF
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
[Partition]
Type=root-${architecture}
CopyFiles=/
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
runas testuser tee "$defs/10-usr.conf" <<EOF
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
[Partition]
Type=usr-${architecture}
CopyFiles=/usr:/
EOF
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
output=$(runas testuser systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=create \
--size=auto \
--json=pretty \
--root="$root" \
"$imgs/zzz")
if systemd-detect-virt --quiet --container; then
echo "Skipping issue 24786 test loop/mount parts in container."
return
fi
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
loop=$(losetup -P --show -f "$imgs/zzz")
udevadm wait --timeout 60 --settle "${loop:?}"
mkdir "$imgs/mnt"
mount -t ext4 "${loop}p1" "$imgs/mnt"
assert_rc 0 ls "$imgs/mnt/abc"
assert_rc 2 ls "$imgs/mnt/usr"
mkdir "$imgs/mnt/usr"
mount -t ext4 "${loop}p2" "$imgs/mnt/usr"
assert_rc 0 ls "$imgs/mnt/usr/def"
umount -R "$imgs/mnt"
losetup -d "$loop"
}
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
test_minimize() {
local defs imgs output
if systemd-detect-virt --quiet --container; then
echo "Skipping minimize test in container."
return
fi
defs="$(mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
repart: support erofs So, i think "erofs" is probably the better, more modern alternative to "squashfs". Many of the benefits don't matter too much to us I guess, but there's one thing that stands out: erofs has a UUID in the superblock, squashfs has not. Having an UUID in the superblock matters if the file systems are used in an overlayfs stack, as overlayfs uses the UUIDs to robustly and persistently reference inodes on layers in case of metadata copy-up. Since we probably want to allow such uses in overlayfs as emplyoed by sysext (and the future syscfg) we probably should ramp up our erofs game early on. Hence let's natively support erofs, test it, and in fact mention it in the docs before squashfs even.
2022-12-09 16:08:54 +01:00
for format in ext4 vfat erofs; do
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
if ! command -v "mkfs.$format" >/dev/null; then
continue
fi
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
tee "$defs/root-$format.conf" <<EOF
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
[Partition]
Type=root-${architecture}
Format=${format}
CopyFiles=${defs}
repart: Fix integration test
2022-12-15 12:01:35 +00:00
Minimize=guess
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
EOF
done
tests: fix inverted condition in testsuite-58.sh (cherry picked from commit 8fd25ba3438487cf79bd693c9022c51699562126)
2023-03-14 10:06:39 +01:00
if command -v mksquashfs >/dev/null; then
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
tee "$defs/root-squashfs.conf" <<EOF
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
[Partition]
Type=root-${architecture}
Format=squashfs
CopyFiles=${defs}
repart: Fix integration test
2022-12-15 12:01:35 +00:00
Minimize=best
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
EOF
fi
output=$(systemd-repart --definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=create \
--size=auto \
--json=pretty \
"$imgs/zzz")
# Check that we can dissect, mount and unmount a minimized image.
systemd-dissect "$imgs/zzz"
systemd-dissect "$imgs/zzz" -M "$imgs/mnt"
systemd-dissect -U "$imgs/mnt"
}
test: add reproducer for issue #28225 (cherry picked from commit beba8f2e1e5f08041d2a9955398a64d92dcc75a0)
2023-07-03 12:11:50 +09:00
testcase_free_area_calculation() {
local defs imgs output
if ! command -v mksquashfs >/dev/null; then
echo "Skipping free area calculation test without squashfs."
return
fi
defs="$(mktemp --directory "/tmp/test-repart.defs.XXXXXXXXXX")"
imgs="$(mktemp --directory "/var/tmp/test-repart.imgs.XXXXXXXXXX")"
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
chmod a+rx "$defs"
# https://github.com/systemd/systemd/issues/28225
echo "*** free area calculation ***"
tee "$defs/00-ESP.conf" <<EOF
[Partition]
Type = esp
Label = ESP
Format = vfat
SizeMinBytes = 128M
SizeMaxBytes = 128M
# Sufficient for testing
CopyFiles = /etc:/
EOF
tee "$defs/10-os.conf" <<EOF
[Partition]
Type = root-${architecture}
Label = test
Format = squashfs
Minimize = best
# Sufficient for testing
CopyFiles = /etc/:/
VerityMatchKey = os
Verity = data
EOF
tee "$defs/11-os-verity.conf" <<EOF
[Partition]
Type = root-${architecture}-verity
Label = test
Minimize = best
VerityMatchKey = os
Verity = hash
EOF
# Set sector size for VFAT to 512 bytes because there will not be enough FAT clusters otherwise
output1=$(SYSTEMD_REPART_MKFS_OPTIONS_VFAT="-S 512" systemd-repart \
--definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=create \
--size=auto \
--sector-size=4096 \
--defer-partitions=esp \
--json=pretty \
"$imgs/zzz")
test: update test for free area calculation in repart (cherry picked from commit 937625c7c72e503d03b406de3e1859d7f00dbdcf)
2023-07-03 15:15:27 +09:00
# The second invocation
test: add reproducer for issue #28225 (cherry picked from commit beba8f2e1e5f08041d2a9955398a64d92dcc75a0)
2023-07-03 12:11:50 +09:00
output2=$(SYSTEMD_REPART_MKFS_OPTIONS_VFAT="-S 512" systemd-repart \
--definitions="$defs" \
--seed="$seed" \
--dry-run=no \
--empty=allow \
--size=auto \
--sector-size=4096 \
--defer-partitions=esp \
--json=pretty \
test: update test for free area calculation in repart (cherry picked from commit 937625c7c72e503d03b406de3e1859d7f00dbdcf)
2023-07-03 15:15:27 +09:00
"$imgs/zzz")
TEST-58-REPART: reverse order of diff args I expect the test output to be the second argument, so we're diffing "expected" and "output", not the other way around. I noticed this when working on https://github.com/systemd/systemd/pull/33081. (cherry picked from commit 6bb3ea655d08c0602c99ccd2a580ba102fd19114) (cherry picked from commit 9663bb74100dd79c1e4e9c6b2377ea1b817ddee5) (cherry picked from commit 5469bc61185163119bec209612e0a72381ba232c) (cherry picked from commit b8b652d11f2c49be5a841fe61c28e038ea1ea04a)
2024-05-30 11:33:20 +02:00
diff -u <(echo "$output1" | grep -E "(offset|raw_size|raw_padding)") \
<(echo "$output2" | grep -E "(offset|raw_size|raw_padding)")
test: add reproducer for issue #28225 (cherry picked from commit beba8f2e1e5f08041d2a9955398a64d92dcc75a0)
2023-07-03 12:11:50 +09:00
}
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
test_sector() {
local defs imgs output loop
local start size ratio
local sector="${1?}"
test: make TEST-58-REPART support nspawn
2022-08-20 04:59:03 +09:00
if systemd-detect-virt --quiet --container; then
echo "Skipping sector size tests in container."
return
fi
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
defs="$(mktemp --directory "/tmp/test-repart.XXXXXXXXXX")"
imgs="$(mktemp --directory "/var/tmp/test-repart.XXXXXXXXXX")"
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
tee "$defs/a.conf" <<EOF
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
[Partition]
Type=root
SizeMaxBytes=15M
SizeMinBytes=15M
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
tee "$defs/b.conf" <<EOF
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
[Partition]
Type=linux-generic
Weight=250
EOF
Revert "repart: Ensure files end up owned by root in generated filesystems" This reverts commit e59678b2cf42e4206ddabc959d3cf9a5a865ecdc. We also modify the repart integration tests to make them pass with the changes in this commit. In short, we have to make sure every file is owned by the user executing repart. We use tee instead of cat since it makes that easier. This also has the benefit of improving debugability as seeing the config file contents on stdout makes it easier to know which test is failing.
2023-01-23 14:47:00 +01:00
tee "$defs/c.conf" <<EOF
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
[Partition]
Type=linux-generic
Weight=750
EOF
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
truncate -s 100m "$imgs/$sector.img"
loop=$(losetup -b "$sector" -P --show -f "$imgs/$sector.img" )
udevadm wait --timeout 60 --settle "${loop:?}"
repart: Run most repart integration tests without root privileges To make sure rootless mode keeps working, let's run all repart integration tests that we can without root privileges. The only ones we need to keep running with root privileges are the tests that operate on a block/loop device and those that use --image=.
2022-11-10 15:40:00 +01:00
# This operates on a loop device which we don't support doing without root privileges so we skip runas
# here.
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
systemd-repart --pretty=yes \
--definitions="$defs" \
--seed="$seed" \
--empty=require \
--dry-run=no \
"$loop"
sfdisk --verify "$loop"
output=$(sfdisk --dump "$loop")
losetup -d "$loop"
ratio=$(( sector / 512 ))
start=$(( 2048 / ratio ))
size=$(( 30720 / ratio ))
assert_in "${loop}p1 : start= *${start}, size= *${size}, type=${root_guid}, uuid=${root_uuid}, name=\"root-${architecture}\", attrs=\"GUID:59\"" "$output"
start=$(( start + size ))
size=$(( 42992 / ratio ))
assert_in "${loop}p2 : start= *${start}, size= *${size}, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=DF71F5E3-080A-4D16-824B-18591B881380, name=\"linux-generic\"" "$output"
start=$(( start + size ))
size=$(( 129000 / ratio ))
assert_in "${loop}p3 : start= *${start}, size= *${size}, type=0FC63DAF-8483-4772-8E79-3D69D8477DE4, uuid=DB081670-07AE-48CA-9F5E-813D5E40B976, name=\"linux-generic-2\"" "$output"
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
}
test: add test case for systemd-repart --seed=random For issue #34257. (cherry picked from commit 56d6ebd40468e2a743b39ad7d87b0675bdf9a042) (cherry picked from commit 69282da9aab90c2dc1e440b04af5b2163779515a) (cherry picked from commit fbfe769c4553b49640733efc82577cf30b02cd94) (cherry picked from commit 1211e6c7709681dac4d3f93e54166c2b846e8e73)
2024-09-05 17:58:29 +09:00
testcase_random_seed() {
local defs imgs output
# For issue #34257
defs="$(mktemp --directory "/tmp/test-repart.defs.XXXXXXXXXX")"
imgs="$(mktemp --directory "/var/tmp/test-repart.imgs.XXXXXXXXXX")"
# shellcheck disable=SC2064
trap "rm -rf '$defs' '$imgs'" RETURN
chmod 0755 "$defs"
tee "$defs/root.conf" <<EOF
[Partition]
Type=root
EOF
tee "$defs/home.conf" <<EOF
[Partition]
Type=home
Label=home-first
EOF
tee "$defs/swap.conf" <<EOF
[Partition]
Type=swap
SizeMaxBytes=64M
PaddingMinBytes=92M
EOF
systemd-repart --definitions="$defs" \
--empty=create \
--size=1G \
--dry-run=no \
--seed=random \
--json=pretty \
"$imgs/zzz"
sfdisk -d "$imgs/zzz"
[[ "$(sfdisk -d "$imgs/zzz" | grep -F 'uuid=' | awk '{ print $8 }' | sort -u | wc -l)" == "3" ]]
}
test: merge test-repart.sh and TEST-58-REPART
2022-08-20 04:37:00 +09:00
test_basic
test_dropin
test_multiple_definitions
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
test_copy_blocks
test_unaligned_partition
test_issue_21817
test-58-repart: add test case for issue #24553
2022-09-05 22:11:55 +09:00
test_issue_24553
repart: Add support for setting a partition's UUID to zero This is useful when we need to fill in the UUID later, such as when using verity partitions.
2022-09-04 18:53:25 +02:00
test_zero_uuid
repart: Add support for formatting verity partitions This commit adds a new Verity= setting to repart definition files with two possible values: "data" and "hash". If Verity= is set to "data", repart works as before, and populates the partition with the content from CopyBlocks= or CopyFiles=. If Verity= is set to "hash", repart will try to find a matching data partition with Verity=data and equal values for CopyBlocks= or CopyFiles=, Format= and MakeDirectories=. If a matching data partition is found, repart will generate verity hashes for that data partition in the verity partition. The UUID of the data partition is set to the first 128 bits of the verity root hash. The UUID of the hashes partition is set to the final 128 bits of the verity root hash. Fixes #24559
2022-09-06 00:45:32 +02:00
test_verity
repart: Add integration test for #24678
2022-11-09 13:41:38 +01:00
test_issue_24786
repart: Add Minimize= integration test
2022-11-10 12:33:02 +01:00
test_minimize
test: add test case for systemd-repart --seed=random For issue #34257. (cherry picked from commit 56d6ebd40468e2a743b39ad7d87b0675bdf9a042) (cherry picked from commit 69282da9aab90c2dc1e440b04af5b2163779515a) (cherry picked from commit fbfe769c4553b49640733efc82577cf30b02cd94) (cherry picked from commit 1211e6c7709681dac4d3f93e54166c2b846e8e73)
2024-09-05 17:58:29 +09:00
testcase_random_seed
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
# Valid block sizes on the Linux block layer are >= 512 and <= PAGE_SIZE, and
# must be powers of 2. Which leaves exactly four different ones to test on
# typical hardware
test: modernize TEST-58-REPART
2022-08-19 16:33:09 +09:00
test_sector 512
test_sector 1024
test_sector 2048
test_sector 4096
tests: add repart tests for block devices with 1024, 2048, 4096 byte sector sizes let's make sure repart works with 4K drives and exotic sector sizes.
2022-02-07 14:35:40 +01:00
test: add test for new repart features
2021-04-19 17:30:33 +02:00
echo OK >/testok
exit 0
Copy Permalink