kernel
/
dracut
mirror of https://git.kernel.org/pub/scm/boot/dracut/dracut.git/
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

ci: get rid of "mount -o loop" 

This finally allows running the test suite completely in a rootless container:
```
❯ podman run \
         --user 0 \
         -v /dev:/dev \
         -v ./:/dracut \
         -it \
         quay.io/haraldh/dracut-fedora:33 \
         bash -c 'cd /dracut; make DRACUT_NO_XATTR=1 check'
```
master
Harald Hoyer 2021-02-05 16:25:14 +01:00 committed by Harald Hoyer
parent 1211d6a3fb
commit 0f62da0405
18 changed files with 505 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
test/TEST-20-NFS/create-root.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e
# save a partition at the beginning for future flagging purposes
sfdisk /dev/sda <<EOF
,1M
,
EOF

udevadm settle
mkfs.ext3 -L dracut /dev/sda2
mkdir -p /root
mount /dev/sda2 /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
echo "dracut-root-block-created" | dd oflag=direct,dsync of=/dev/sda1
sync
poweroff -f

46
test/TEST-20-NFS/test.sh
View File

@ -23,7 +23,6 @@ run_server() {
# Start server first
echo "NFS TEST SETUP: Starting DHCP/NFS server"

fsck -a $TESTDIR/server.ext3 || return 1
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-net socket,listen=127.0.0.1:12320 \
@ -31,7 +30,7 @@ run_server() {
${SERIAL:+-serial "$SERIAL"} \
${SERIAL:--serial file:"$TESTDIR"/server.log} \
-watchdog i6300esb -watchdog-action poweroff \
-append "panic=1 quiet root=/dev/sda rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0" \
-append "panic=1 quiet root=LABEL=dracut rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.server \
-pidfile $TESTDIR/server.pid -daemonize || return 1
chmod 644 $TESTDIR/server.pid || return 1
@ -226,17 +225,14 @@ test_run() {
test_setup() {
# Make server root
dd if=/dev/zero of=$TESTDIR/server.ext3 bs=1M count=120
mke2fs -j -F $TESTDIR/server.ext3
mkdir $TESTDIR/mnt
mount -o loop $TESTDIR/server.ext3 $TESTDIR/mnt


export kernel=$KVERSION
export srcmods="/lib/modules/$kernel/"
# Detect lib paths

(
export initdir=$TESTDIR/mnt
mkdir -p $TESTDIR/server/overlay/source
export initdir=$TESTDIR/server/overlay/source
. $basedir/dracut-init.sh

for _f in modules.builtin.bin modules.builtin; do
@ -297,12 +293,13 @@ test_setup() {
cp -a /etc/ld.so.conf* $initdir/etc
ldconfig -r "$initdir"
dracut_kernel_post

)


# Make client root inside server root
(
export initdir=$TESTDIR/mnt/nfs/client
export initdir=$TESTDIR/server/overlay/source/nfs/client
. $basedir/dracut-init.sh

inst_multiple sh shutdown poweroff stty cat ps ln ip dd \
@ -341,12 +338,35 @@ test_setup() {
ldconfig -r "$initdir"
)

mkdir -p $TESTDIR/mnt/nfs/nfs3-5
mkdir -p $TESTDIR/mnt/nfs/ip/192.168.50.101
mkdir -p $TESTDIR/mnt/nfs/tftpboot/nfs4-5
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/server/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/server/overlay / \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1
rm -rf -- $TESTDIR/server
# Invoke KVM and/or QEMU to actually create the target filesystem.

$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/server.ext3 || return 1


umount $TESTDIR/mnt
rm -fr -- $TESTDIR/mnt

# Make an overlay with needed tools for the test harness
(

0
test/TEST-30-ISCSI/create-root.sh → test/TEST-30-ISCSI/create-client-root.sh
View File

25
test/TEST-30-ISCSI/create-server-root.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e
# save a partition at the beginning for future flagging purposes
sfdisk /dev/sda <<EOF
,1M
,
EOF

udevadm settle
mkfs.ext3 -L dracut /dev/sda2
mkdir -p /root
mount /dev/sda2 /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
echo "dracut-root-block-created" | dd oflag=direct,dsync of=/dev/sda1
sync
poweroff -f

57
test/TEST-30-ISCSI/test.sh
View File

@ -32,7 +32,7 @@ run_server() {
-net nic,macaddr=52:54:00:12:34:56,model=e1000 \
-net nic,macaddr=52:54:00:12:34:57,model=e1000 \
-net socket,listen=127.0.0.1:12330 \
-append "panic=1 quiet root=/dev/sda rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 $SERVER_DEBUG" \
-append "panic=1 quiet root=/dev/sda2 rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 $SERVER_DEBUG" \
-initrd $TESTDIR/initramfs.server \
-pidfile $TESTDIR/server.pid -daemonize || return 1
chmod 644 $TESTDIR/server.pid || return 1
@ -165,7 +165,7 @@ test_setup() {
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount setsid dd
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue 01 ./create-client-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)
@ -180,7 +180,6 @@ test_setup() {
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1
rm -rf -- $TESTDIR/overlay


# Need this so kvm-qemu will boot (needs non-/dev/zero local disk)
if ! dd if=/dev/zero of=$TESTDIR/client.img bs=1M count=1; then
echo "Unable to make client sdb image" 1>&2
@ -196,17 +195,17 @@ test_setup() {
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/client.img || return 1
rm -- $TESTDIR/client.img
rm -rf -- $TESTDIR/overlay


# Make server root
dd if=/dev/zero of=$TESTDIR/server.ext3 bs=1M count=60
mkfs.ext3 -j -F $TESTDIR/server.ext3
mkdir $TESTDIR/mnt
mount -o loop $TESTDIR/server.ext3 $TESTDIR/mnt
dd if=/dev/zero of=$TESTDIR/server.ext3 bs=1M count=120

kernel=$KVERSION
rm -rf -- $TESTDIR/overlay
(
export initdir=$TESTDIR/mnt
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. $basedir/dracut-init.sh
(
cd "$initdir";
@ -238,19 +237,35 @@ test_setup() {
dracut_kernel_post
)

umount $TESTDIR/mnt
rm -fr -- $TESTDIR/mnt
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-server-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# Make server's dracut image
# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-a "dash udev-rules base rootfs-block fs-lib debug kernel-modules" \
-d "af_packet piix ide-gd_mod ata_piix ext3 sd_mod e1000 drbg" \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.server $KVERSION || return 1
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/server.ext3 || return 1
rm -rf -- $TESTDIR/overlay

# Make client dracut image
rm -rf -- $TESTDIR/overlay
# Make an overlay with needed tools for the test harness
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
@ -258,7 +273,17 @@ test_setup() {
inst_hook shutdown-emergency 000 ./hard-off.sh
inst_hook emergency 000 ./hard-off.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
inst_simple ./99-default.link /etc/systemd/network/99-default.link
)

# Make server's dracut image
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-a "dash udev-rules base rootfs-block fs-lib debug kernel-modules" \
-d "af_packet piix ide-gd_mod ata_piix ext3 sd_mod e1000 drbg" \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.server $KVERSION || return 1

# Make client dracut image
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-o "dash plymouth dmraid nfs ${OMIT_NETWORK}" \
-a "debug ${USE_NETWORK}" \

0
test/TEST-35-ISCSI-MULTI/create-root.sh → test/TEST-35-ISCSI-MULTI/create-client-root.sh
View File

25
test/TEST-35-ISCSI-MULTI/create-server-root.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e
# save a partition at the beginning for future flagging purposes
sfdisk /dev/sda <<EOF
,1M
,
EOF

udevadm settle
mkfs.ext3 -L dracut /dev/sda2
mkdir -p /root
mount /dev/sda2 /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
echo "dracut-root-block-created" | dd oflag=direct,dsync of=/dev/sda1
sync
poweroff -f

54
test/TEST-35-ISCSI-MULTI/test.sh
View File

@ -32,7 +32,7 @@ run_server() {
-net nic,macaddr=52:54:00:12:34:56,model=e1000 \
-net nic,macaddr=52:54:00:12:34:57,model=e1000 \
-net socket,listen=127.0.0.1:12331 \
-append "panic=1 systemd.crash_reboot root=/dev/sda rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 $SERVER_DEBUG" \
-append "panic=1 systemd.crash_reboot root=/dev/sda2 rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 $SERVER_DEBUG" \
-initrd $TESTDIR/initramfs.server \
-pidfile $TESTDIR/server.pid -daemonize || return 1
chmod 644 $TESTDIR/server.pid || return 1
@ -180,7 +180,7 @@ test_setup() {
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount setsid dd
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue 01 ./create-client-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)
@ -213,15 +213,15 @@ test_setup() {
rm -- $TESTDIR/client.img

# Make server root
echo "MAKE SERVER ROOT"

dd if=/dev/zero of=$TESTDIR/server.ext3 bs=1M count=60
mkfs.ext3 -j -F $TESTDIR/server.ext3
mkdir $TESTDIR/mnt
mount -o loop $TESTDIR/server.ext3 $TESTDIR/mnt

kernel=$KVERSION
rm -rf -- $TESTDIR/overlay
(
export initdir=$TESTDIR/mnt
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. $basedir/dracut-init.sh
(
cd "$initdir";
@ -252,20 +252,35 @@ test_setup() {
ldconfig -r "$initdir"
dracut_kernel_post
)
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-server-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

umount $TESTDIR/mnt
rm -fr -- $TESTDIR/mnt

# Make server's dracut image
# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-a "dash udev-rules base rootfs-block fs-lib debug kernel-modules" \
-d "af_packet piix ide-gd_mod ata_piix ext3 sd_mod e1000 drbg" \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.server $KVERSION || return 1
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1


# Make client dracut image
# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/server.ext3 || return 1
rm -rf -- $TESTDIR/overlay

# Make an overlay with needed tools for the test harness
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
@ -274,6 +289,15 @@ test_setup() {
inst_hook emergency 000 ./hard-off.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# Make server's dracut image
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-a "dash udev-rules base rootfs-block fs-lib debug kernel-modules" \
-d "af_packet piix ide-gd_mod ata_piix ext3 sd_mod e1000 drbg" \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.server $KVERSION || return 1

# Make client's dracut image
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-o "dash plymouth dmraid nfs ${OMIT_NETWORK}" \
-a "debug ${USE_NETWORK}" \

19
test/TEST-40-NBD/create-client-root.sh Executable file
View File

@ -0,0 +1,19 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e

udevadm settle
mkfs.ext3 -L dracut /dev/sda
mkdir -p /root
mount /dev/sda /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
{ echo "dracut-root-block-created"; echo "ID_FS_UUID=$ID_FS_UUID"; } | dd oflag=direct,dsync of=/dev/sdb
sync
poweroff -f

11
test/TEST-40-NBD/create-root.sh → test/TEST-40-NBD/create-encrypted-root.sh
View File

@ -6,15 +6,14 @@ done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
printf test >keyfile
cryptsetup -q luksFormat /dev/sdb /keyfile
cryptsetup -q luksFormat /dev/sda /keyfile
echo "The passphrase is test"
cryptsetup luksOpen /dev/sdb dracut_crypt_test </keyfile && \
cryptsetup luksOpen /dev/sda dracut_crypt_test </keyfile && \
lvm pvcreate -ff -y /dev/mapper/dracut_crypt_test && \
lvm vgcreate dracut /dev/mapper/dracut_crypt_test && \
lvm lvcreate -l 100%FREE -n root dracut && \
lvm vgchange -ay && \
mke2fs -L dracut -j /dev/dracut/root && \
/sbin/tune2fs -e continue /dev/dracut/root && \
mkfs.ext3 -L dracut -j /dev/dracut/root && \
mkdir -p /sysroot && \
mount /dev/dracut/root /sysroot && \
cp -a -t /sysroot /source/* && \
@ -25,6 +24,6 @@ udevadm settle
cryptsetup luksClose /dev/mapper/dracut_crypt_test
udevadm settle
sleep 1
eval $(udevadm info --query=env --name=/dev/sdb|while read line || [ -n "$line" ]; do [ "$line" != "${line#*ID_FS_UUID*}" ] && echo $line; done;)
{ echo "dracut-root-block-created"; echo "ID_FS_UUID=$ID_FS_UUID"; } | dd oflag=direct,dsync of=/dev/sda
eval $(udevadm info --query=env --name=/dev/sda|while read line || [ -n "$line" ]; do [ "$line" != "${line#*ID_FS_UUID*}" ] && echo $line; done;)
{ echo "dracut-root-block-created"; echo "ID_FS_UUID=$ID_FS_UUID"; } | dd oflag=direct,dsync of=/dev/sdb
poweroff -f

19
test/TEST-40-NBD/create-server-root.sh Executable file
View File

@ -0,0 +1,19 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e

udevadm settle
mkfs.ext3 -L dracut /dev/sda
mkdir -p /root
mount /dev/sda /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
{ echo "dracut-root-block-created"; echo "ID_FS_UUID=$ID_FS_UUID"; } | dd oflag=direct,dsync of=/dev/sdb
sync
poweroff -f

182
test/TEST-40-NBD/test.sh
View File

@ -30,14 +30,14 @@ run_server() {
echo "NBD TEST SETUP: Starting DHCP/NBD server"

$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext2 \
-drive format=raw,index=1,media=disk,file=$TESTDIR/nbd.ext2 \
-drive format=raw,index=2,media=disk,file=$TESTDIR/encrypted.ext2 \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-drive format=raw,index=1,media=disk,file=$TESTDIR/nbd.ext3 \
-drive format=raw,index=2,media=disk,file=$TESTDIR/encrypted.ext3 \
-net nic,macaddr=52:54:00:12:34:56,model=e1000 \
-net socket,listen=127.0.0.1:12340 \
${SERIAL:+-serial "$SERIAL"} \
${SERIAL:--serial file:"$TESTDIR"/server.log} \
-append "panic=1 systemd.crash_reboot root=/dev/sda rootfstype=ext2 rw quiet console=ttyS0,115200n81 selinux=0" \
-append "panic=1 systemd.crash_reboot root=/dev/sda rootfstype=ext3 rw quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.server -pidfile $TESTDIR/server.pid -daemonize || return 1
chmod 644 $TESTDIR/server.pid || return 1

@ -48,6 +48,7 @@ run_server() {
echo "Waiting for the server to startup"
while : ; do
grep Serving "$TESTDIR"/server.log && break
tail "$TESTDIR"/server.log
sleep 1
done
else
@ -71,7 +72,7 @@ client_test() {

# Clear out the flags for each test
if ! dd if=/dev/zero of=$TESTDIR/flag.img bs=1M count=1; then
echo "Unable to make client sda image" 1>&2
echo "Unable to make client flag image" 1>&2
return 1
fi

@ -132,15 +133,11 @@ client_run() {
ext3 errors=panic || return 1

client_test "NBD root=nbd:IP:port:fstype" 52:54:00:12:34:00 \
"root=nbd:192.168.50.1:raw:ext2 rd.luks=0" ext2 || return 1
"root=nbd:192.168.50.1:raw:ext3 rd.luks=0" ext3 || return 1

client_test "NBD root=nbd:IP:port:fstype:fsopts" 52:54:00:12:34:00 \
"root=nbd:192.168.50.1:raw:ext2:errors=panic rd.luks=0" \
ext2 errors=panic || return 1

client_test "NBD Bridge root=nbd:IP:port:fstype:fsopts" 52:54:00:12:34:00 \
"root=nbd:192.168.50.1:raw:ext2:errors=panic bridge rd.luks=0" \
ext2 errors=panic || return 1
"root=nbd:192.168.50.1:raw:ext3:errors=panic rd.luks=0" \
ext3 errors=panic || return 1

#
# FIXME! These fail, but probably shouldn't
@ -153,47 +150,44 @@ client_run() {
# "root=nbd:192.168.50.1:raw:::bs=2048 rd.luks=0" || return 1
#
# client_test "NBD root=nbd:IP:port:fstype::NBD opts" 52:54:00:12:34:00 \
# "root=nbd:192.168.50.1:raw:ext2::bs=2048 rd.luks=0" ext2 || return 1
# "root=nbd:192.168.50.1:raw:ext3::bs=2048 rd.luks=0" ext3 || return 1
#
# client_test "NBD root=nbd:IP:port:fstype:fsopts:NBD opts" \
# 52:54:00:12:34:00 \
# "root=nbd:192.168.50.1:raw:ext2:errors=panic:bs=2048 rd.luks=0" \
# ext2 errors=panic || return 1
# "root=nbd:192.168.50.1:raw:ext3:errors=panic:bs=2048 rd.luks=0" \
# ext3 errors=panic || return 1

# DHCP root-path parsing

# client_test "NBD root=dhcp DHCP root-path nbd:srv:port" 52:54:00:12:34:01 \
# "root=dhcp rd.luks=0" || return 1
client_test "NBD root=dhcp DHCP root-path nbd:srv:port" 52:54:00:12:34:01 \
"root=dhcp rd.luks=0" || return 1

# client_test "NBD Bridge root=dhcp DHCP root-path nbd:srv:port" 52:54:00:12:34:01 \
# "root=dhcp bridge rd.luks=0" || return 1
client_test "NBD root=dhcp DHCP root-path nbd:srv:port:fstype" \
52:54:00:12:34:02 "root=dhcp rd.luks=0" ext3 || return 1

# client_test "NBD root=dhcp DHCP root-path nbd:srv:port:fstype" \
# 52:54:00:12:34:02 "root=dhcp rd.luks=0" ext2 || return 1
client_test "NBD root=dhcp DHCP root-path nbd:srv:port::fsopts" \
52:54:00:12:34:03 "root=dhcp rd.luks=0" ext3 errors=panic || return 1

# client_test "NBD root=dhcp DHCP root-path nbd:srv:port::fsopts" \
# 52:54:00:12:34:03 "root=dhcp rd.luks=0" ext3 errors=panic || return 1

# client_test "NBD root=dhcp DHCP root-path nbd:srv:port:fstype:fsopts" \
# 52:54:00:12:34:04 "root=dhcp rd.luks=0" ext2 errors=panic || return 1
client_test "NBD root=dhcp DHCP root-path nbd:srv:port:fstype:fsopts" \
52:54:00:12:34:04 "root=dhcp rd.luks=0" ext3 errors=panic || return 1

# netroot handling

# client_test "NBD netroot=nbd:IP:port" 52:54:00:12:34:00 \
# "netroot=nbd:192.168.50.1:raw rd.luks=0" || return 1
#
# client_test "NBD netroot=dhcp DHCP root-path nbd:srv:port:fstype:fsopts" \
# 52:54:00:12:34:04 "netroot=dhcp rd.luks=0" ext2 errors=panic || return 1
client_test "NBD netroot=nbd:IP:port" 52:54:00:12:34:00 \
"netroot=nbd:192.168.50.1:raw rd.luks=0" || return 1

client_test "NBD netroot=dhcp DHCP root-path nbd:srv:port:fstype:fsopts" \
52:54:00:12:34:04 "netroot=dhcp rd.luks=0" ext3 errors=panic || return 1

# Encrypted root handling via LVM/LUKS over NBD

# . $TESTDIR/luks.uuid
#
# client_test "NBD root=LABEL=dracut netroot=nbd:IP:port" \
# 52:54:00:12:34:00 \
# "root=LABEL=dracut rd.luks.uuid=$ID_FS_UUID rd.lv.vg=dracut netroot=nbd:192.168.50.1:encrypted" || return 1
. $TESTDIR/luks.uuid

# XXX This should be ext2,errors=panic but that doesn't currently
client_test "NBD root=LABEL=dracut netroot=nbd:IP:port" \
52:54:00:12:34:00 \
"root=LABEL=dracut rd.luks.uuid=$ID_FS_UUID rd.lv.vg=dracut netroot=nbd:192.168.50.1:encrypted" || return 1

# XXX This should be ext3,errors=panic but that doesn't currently
# XXX work when you have a real root= line in addition to netroot=
# XXX How we should work here needs clarification
# client_test "NBD root=LABEL=dracut netroot=dhcp (w/ fstype and opts)" \
@ -209,9 +203,10 @@ client_run() {

make_encrypted_root() {
# Create the blank file to use as a root filesystem
dd if=/dev/zero of=$TESTDIR/encrypted.ext2 bs=1M count=80
dd if=/dev/zero of=$TESTDIR/encrypted.ext3 bs=1M count=80
dd if=/dev/zero of=$TESTDIR/flag.img bs=1M count=1

rm -fr "$TESTDIR"/overlay
kernel=$KVERSION
# Create what will eventually be our root filesystem onto an overlay
(
@ -220,12 +215,13 @@ make_encrypted_root() {
mkdir -p "$initdir"
(
cd "$initdir"
mkdir -p dev sys proc etc var tmp run root usr/bin usr/lib usr/lib64 usr/sbin
mkdir -p -- dev sys proc etc var/run tmp
mkdir -p root usr/bin usr/lib usr/lib64 usr/sbin
for i in bin sbin lib lib64; do
ln -sfnr usr/$i $i
done
ln -s ../run var/run
)

inst_multiple sh df free ls shutdown poweroff stty cat ps ln ip \
mount dmesg mkdir cp ping dd
for _terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do
@ -251,10 +247,10 @@ make_encrypted_root() {
done
ln -s ../run var/run
)
inst_multiple mke2fs poweroff cp umount tune2fs dd
inst_multiple mkfs.ext3 poweroff cp umount dd
inst_hook shutdown-emergency 000 ./hard-off.sh
inst_hook emergency 000 ./hard-off.sh
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue 01 ./create-encrypted-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)
@ -264,15 +260,15 @@ make_encrypted_root() {
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash crypt lvm mdraid udev-rules base rootfs-block fs-lib kernel-modules qemu" \
-d "piix ide-gd_mod ata_piix ext2 ext3 sd_mod" \
-d "piix ide-gd_mod ata_piix ext3 ext3 sd_mod" \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1
rm -rf -- $TESTDIR/overlay

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/flag.img \
-drive format=raw,index=1,media=disk,file=$TESTDIR/encrypted.ext2 \
-drive format=raw,index=0,media=disk,file=$TESTDIR/encrypted.ext3 \
-drive format=raw,index=1,media=disk,file=$TESTDIR/flag.img \
-append "root=/dev/fakeroot rw quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/flag.img || return 1
@ -280,26 +276,23 @@ make_encrypted_root() {
}

make_client_root() {
dd if=/dev/zero of=$TESTDIR/nbd.ext2 bs=1M count=120
mke2fs -F -j $TESTDIR/nbd.ext2
mkdir $TESTDIR/mnt
if ! mount -o loop $TESTDIR/nbd.ext2 $TESTDIR/mnt; then
echo "Cannot mount loop"
return 1
fi
dd if=/dev/zero of=$TESTDIR/nbd.ext3 bs=1M count=120
dd if=/dev/zero of=$TESTDIR/flag.img bs=1M count=1

rm -fr "$TESTDIR"/overlay
kernel=$KVERSION
(
export initdir=$TESTDIR/mnt
. $basedir/dracut-init.sh
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. "$basedir"/dracut-init.sh
mkdir -p "$initdir"
(
cd "$initdir"
mkdir -p dev sys proc etc var tmp run root usr/bin usr/lib usr/lib64 usr/sbin
mkdir -p -- dev sys proc etc var/run tmp
mkdir -p root usr/bin usr/lib usr/lib64 usr/sbin
for i in bin sbin lib lib64; do
ln -sfnr usr/$i $i
done
ln -s ../run var/run
)
inst_multiple sh ls shutdown poweroff stty cat ps ln ip \
dmesg mkdir cp ping dd
@ -320,20 +313,46 @@ make_client_root() {
ldconfig -r "$initdir"
)

umount $TESTDIR/mnt
rm -fr -- $TESTDIR/mnt
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-client-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/nbd.ext3 \
-drive format=raw,index=1,media=disk,file=$TESTDIR/flag.img \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/flag.img || return 1
rm -fr "$TESTDIR"/overlay
}

make_server_root() {
dd if=/dev/zero of=$TESTDIR/server.ext2 bs=1M count=120
mke2fs -F $TESTDIR/server.ext2
mkdir $TESTDIR/mnt
mount -o loop $TESTDIR/server.ext2 $TESTDIR/mnt
dd if=/dev/zero of=$TESTDIR/server.ext3 bs=1M count=120
dd if=/dev/zero of=$TESTDIR/flag.img bs=1M count=1

rm -fr $TESTDIR/overlay
kernel=$KVERSION
(
export initdir=$TESTDIR/mnt
. $basedir/dracut-init.sh
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. "$basedir"/dracut-init.sh
mkdir -p "$initdir"
(
cd "$initdir";
@ -377,8 +396,34 @@ EOF
ldconfig -r "$initdir"
)

umount $TESTDIR/mnt
rm -fr -- $TESTDIR/mnt
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-server-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-drive format=raw,index=1,media=disk,file=$TESTDIR/flag.img \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/flag.img || return 1
rm -fr "$TESTDIR"/overlay
}

test_setup() {
@ -386,6 +431,7 @@ test_setup() {
make_client_root || return 1
make_server_root || return 1

rm -fr $TESTDIR/overlay
# Make the test image
(
export initdir=$TESTDIR/overlay
@ -407,14 +453,14 @@ test_setup() {

$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash udev-rules rootfs-block fs-lib base debug kernel-modules" \
-d "af_packet piix ide-gd_mod ata_piix ext2 ext3 sd_mod e1000" \
-d "af_packet piix ide-gd_mod ata_piix ext3 ext3 sd_mod e1000" \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.server $KVERSION || return 1

$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-o "plymouth" \
-a "debug watchdog" \
-d "af_packet piix ide-gd_mod ata_piix ext2 ext3 sd_mod e1000 i6300esb ib700wdt" \
-d "af_packet piix ide-gd_mod ata_piix ext3 ext3 sd_mod e1000 i6300esb ib700wdt" \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.testing $KVERSION || return 1
}

25
test/TEST-50-MULTINIC/create-root.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e
# save a partition at the beginning for future flagging purposes
sfdisk /dev/sda <<EOF
,1M
,
EOF

udevadm settle
mkfs.ext3 -L dracut /dev/sda2
mkdir -p /root
mount /dev/sda2 /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
echo "dracut-root-block-created" | dd oflag=direct,dsync of=/dev/sda1
sync
poweroff -f

9
test/TEST-50-MULTINIC/server-init.sh
View File

@ -4,6 +4,7 @@ set -x
export PATH=/sbin:/bin:/usr/sbin:/usr/bin
export TERM=linux
export PS1='nfstest-server:\w\$ '
echo > /dev/watchdog
stty sane
echo "made it to the rootfs!"
echo server > /proc/sys/kernel/hostname
@ -53,14 +54,14 @@ linkup() {
&& wait_for_if_up $1 2>/dev/null
}

wait_for_if_link eth0 ens3
wait_for_if_link eth0 ens2

>/dev/watchdog
ip addr add 127.0.0.1/8 dev lo
linkup lo
ip link set dev eth0 name ens3
ip addr add 192.168.50.1/24 dev ens3
linkup ens3
ip link set dev eth0 name ens2
ip addr add 192.168.50.1/24 dev ens2
linkup ens2

>/dev/watchdog
modprobe af_packet

50
test/TEST-50-MULTINIC/test.sh
View File

@ -16,12 +16,12 @@ KVERSION=${KVERSION-$(uname -r)}
#DEBUGFAIL="rd.shell rd.break"
#SERIAL="tcp:127.0.0.1:9999"



run_server() {
# Start server first
echo "MULTINIC TEST SETUP: Starting DHCP/NFS server"

fsck -a "$TESTDIR"/server.ext3 || return 1

$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file="$TESTDIR"/server.ext3 \
-net socket,listen=127.0.0.1:12350 \
@ -29,7 +29,7 @@ run_server() {
${SERIAL:+-serial "$SERIAL"} \
${SERIAL:--serial file:"$TESTDIR"/server.log} \
-watchdog i6300esb -watchdog-action poweroff \
-append "panic=1 systemd.crash_reboot loglevel=7 root=/dev/sda rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0" \
-append "panic=1 systemd.crash_reboot loglevel=7 root=LABEL=dracut rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0" \
-initrd "$TESTDIR"/initramfs.server \
-pidfile "$TESTDIR"/server.pid -daemonize || return 1

@ -42,6 +42,7 @@ run_server() {
while : ; do
grep Serving "$TESTDIR"/server.log && break
echo "Waiting for the server to startup"
tail "$TESTDIR"/server.log
sleep 1
done
else
@ -174,13 +175,13 @@ test_client() {
test_setup() {
# Make server root
dd if=/dev/zero of="$TESTDIR"/server.ext3 bs=1M count=120
mke2fs -j -F -- "$TESTDIR"/server.ext3
mkdir -- "$TESTDIR"/mnt
mount -o loop -- "$TESTDIR"/server.ext3 "$TESTDIR"/mnt

kernel=$KVERSION
(
export initdir="$TESTDIR"/mnt
. "$basedir"/dracut-init.sh
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. $basedir/dracut-init.sh


(
cd "$initdir";
@ -245,8 +246,8 @@ test_setup() {

# Make client root inside server root
(
export initdir="$TESTDIR"/mnt/nfs/client
. "$basedir"/dracut-init.sh
export initdir=$TESTDIR/overlay/source/nfs/client
. $basedir/dracut-init.sh
(
cd "$initdir"
mkdir -p dev sys proc etc run
@ -284,8 +285,33 @@ test_setup() {
ldconfig -r "$initdir"
)

umount "$TESTDIR"/mnt
rm -fr -- "$TESTDIR"/mnt
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/server.ext3 || return 1
rm -fr "$TESTDIR"/overlay

# Make an overlay with needed tools for the test harness
(

25
test/TEST-60-BONDBRIDGEVLANIFCFG/create-root.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# don't let udev and this script step on eachother's toes
for x in 64-lvm.rules 70-mdadm.rules 99-mount-rules; do
> "/etc/udev/rules.d/$x"
done
rm -f -- /etc/lvm/lvm.conf
udevadm control --reload
set -e
# save a partition at the beginning for future flagging purposes
sfdisk /dev/sda <<EOF
,1M
,
EOF

udevadm settle
mkfs.ext3 -L dracut /dev/sda2
mkdir -p /root
mount /dev/sda2 /root
cp -a -t /root /source/*
mkdir -p /root/run
umount /root
echo "dracut-root-block-created" | dd oflag=direct,dsync of=/dev/sda1
sync
poweroff -f

59
test/TEST-60-BONDBRIDGEVLANIFCFG/server-init.sh
View File

@ -11,7 +11,10 @@ echo server > /proc/sys/kernel/hostname
wait_for_if_link() {
local cnt=0
local li

while [ $cnt -lt 600 ]; do
ip link show

li=$(ip -o link show dev $1 2>/dev/null)
[ -n "$li" ] && return 0
if [[ $2 ]]; then
@ -53,38 +56,42 @@ linkup() {
&& wait_for_if_up $1 2>/dev/null
}

wait_for_if_link eth0 ens2
wait_for_if_link eth1 ens3
wait_for_if_link eth2 ens4
wait_for_if_link eth3 ens5
udevadm settle

ip link show

wait_for_if_link eth0 ens3
wait_for_if_link eth1 ens4
wait_for_if_link eth2 ens5
wait_for_if_link eth3 ens6

modprobe --all -b -q 8021q ipvlan macvlan
>/dev/watchdog
ip addr add 127.0.0.1/8 dev lo
linkup lo
ip link set dev eth0 name ens2
ip addr add 192.168.50.1/24 dev ens2
linkup ens2
>/dev/watchdog
ip link set dev eth1 name ens3
ip link add dev ens3.1 link ens3 type vlan id 1
ip link add dev ens3.2 link ens3 type vlan id 2
ip link add dev ens3.3 link ens3 type vlan id 3
ip link add dev ens3.4 link ens3 type vlan id 4
ip addr add 192.168.54.1/24 dev ens3.1
ip addr add 192.168.55.1/24 dev ens3.2
ip addr add 192.168.56.1/24 dev ens3.3
ip addr add 192.168.57.1/24 dev ens3.4
ip link set dev eth0 name ens3
ip addr add 192.168.50.1/24 dev ens3
linkup ens3
ip link set dev ens3.1 up
ip link set dev ens3.2 up
ip link set dev ens3.3 up
ip link set dev ens3.4 up
ip link set dev eth2 name ens4
ip addr add 192.168.51.1/24 dev ens4
>/dev/watchdog
ip link set dev eth1 name ens4
ip link add dev ens4.1 link ens4 type vlan id 1
ip link add dev ens4.2 link ens4 type vlan id 2
ip link add dev ens4.3 link ens4 type vlan id 3
ip link add dev ens4.4 link ens4 type vlan id 4
ip addr add 192.168.54.1/24 dev ens4.1
ip addr add 192.168.55.1/24 dev ens4.2
ip addr add 192.168.56.1/24 dev ens4.3
ip addr add 192.168.57.1/24 dev ens4.4
linkup ens4
ip link set dev eth3 name ens5
ip link set dev ens4.1 up
ip link set dev ens4.2 up
ip link set dev ens4.3 up
ip link set dev ens4.4 up
ip link set dev eth2 name ens5
ip addr add 192.168.51.1/24 dev ens5
linkup ens5
ip link set dev eth3 name ens6
linkup ens6
>/dev/watchdog
modprobe af_packet
> /dev/watchdog
@ -115,10 +122,10 @@ exportfs -r
>/dev/watchdog
chmod 777 /var/lib/dhcpd/dhcpd.leases
>/dev/watchdog
dhcpd -cf /etc/dhcpd.conf -lf /var/lib/dhcpd/dhcpd.leases ens2 ens4
dhcpd -cf /etc/dhcpd.conf -lf /var/lib/dhcpd/dhcpd.leases ens3 ens5
#echo -n 'V' > /dev/watchdog
#sh -i
#tcpdump -i ens2
#tcpdump -i ens3
# Wait forever for the VM to die
echo "Serving"
while :; do

45
test/TEST-60-BONDBRIDGEVLANIFCFG/test.sh
View File

@ -24,8 +24,6 @@ run_server() {
# Start server first
echo "MULTINIC TEST SETUP: Starting DHCP/NFS server"

fsck -a "$TESTDIR"/server.ext3 || return 1

$testdir/run-qemu \
-hda "$TESTDIR"/server.ext3 \
-netdev socket,id=n0,listen=127.0.0.1:12370 \
@ -39,7 +37,7 @@ run_server() {
${SERIAL:+-serial "$SERIAL"} \
${SERIAL:--serial file:"$TESTDIR"/server.log} \
-watchdog i6300esb -watchdog-action poweroff \
-append "panic=1 loglevel=7 root=/dev/sda rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 rd.debug" \
-append "panic=1 loglevel=7 root=LABEL=dracut rootfstype=ext3 rw console=ttyS0,115200n81 selinux=0 rd.debug" \
-initrd "$TESTDIR"/initramfs.server \
-pidfile "$TESTDIR"/server.pid -daemonize || return 1
chmod 644 -- "$TESTDIR"/server.pid || return 1
@ -51,6 +49,7 @@ run_server() {
echo "Waiting for the server to startup"
while : ; do
grep Serving "$TESTDIR"/server.log && break
tail "$TESTDIR"/server.log
sleep 1
done
else
@ -200,12 +199,11 @@ root=nfs:192.168.50.1:/nfs/client bootdev=br0
test_setup() {
# Make server root
dd if=/dev/zero of="$TESTDIR"/server.ext3 bs=1M count=120
mke2fs -j -F -- "$TESTDIR"/server.ext3
mkdir -- "$TESTDIR"/mnt
mount -o loop -- "$TESTDIR"/server.ext3 "$TESTDIR"/mnt

kernel=$KVERSION
(
export initdir="$TESTDIR"/mnt
mkdir -p $TESTDIR/overlay/source
export initdir=$TESTDIR/overlay/source
. "$basedir"/dracut-init.sh

(
@ -271,8 +269,8 @@ test_setup() {

# Make client root inside server root
(
export initdir="$TESTDIR"/mnt/nfs/client
. "$basedir"/dracut-init.sh
export initdir=$TESTDIR/overlay/source/nfs/client
. $basedir/dracut-init.sh
inst_multiple sh shutdown poweroff stty cat ps ln ip \
mount dmesg mkdir cp ping grep ls sort dd
for _terminfodir in /lib/terminfo /etc/terminfo /usr/share/terminfo; do
@ -306,8 +304,33 @@ test_setup() {
ldconfig -r "$initdir"
)

umount "$TESTDIR"/mnt
rm -fr -- "$TESTDIR"/mnt
# second, install the files needed to make the root filesystem
(
export initdir=$TESTDIR/overlay
. $basedir/dracut-init.sh
inst_multiple sfdisk mkfs.ext3 poweroff cp umount sync dd
inst_hook initqueue 01 ./create-root.sh
inst_hook initqueue/finished 01 ./finished-false.sh
inst_simple ./99-idesymlinks.rules /etc/udev/rules.d/99-idesymlinks.rules
)

# create an initramfs that will create the target root filesystem.
# We do it this way so that we do not risk trashing the host mdraid
# devices, volume groups, encrypted partitions, etc.
$basedir/dracut.sh -l -i $TESTDIR/overlay / \
-m "dash udev-rules base rootfs-block fs-lib kernel-modules fs-lib qemu" \
-d "piix ide-gd_mod ata_piix ext3 sd_mod" \
--nomdadmconf \
--no-hostonly-cmdline -N \
-f $TESTDIR/initramfs.makeroot $KVERSION || return 1

# Invoke KVM and/or QEMU to actually create the target filesystem.
$testdir/run-qemu \
-drive format=raw,index=0,media=disk,file=$TESTDIR/server.ext3 \
-append "root=/dev/dracut/root rw rootfstype=ext3 quiet console=ttyS0,115200n81 selinux=0" \
-initrd $TESTDIR/initramfs.makeroot || return 1
grep -F -m 1 -q dracut-root-block-created $TESTDIR/server.ext3 || return 1
rm -fr "$TESTDIR"/overlay

# Make an overlay with needed tools for the test harness
(