ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* Convert most Tuxrun Avocado tests to the new functional framework 

* Update the OpenBSD CI image to OpenBSD v7.6
 * Bump timeout of the ide-test
 * New maintainer for the QTests
 * Disable the pci-bridge on s390x by default
 -----BEGIN PGP SIGNATURE-----
 
 iQJFBAABCAAvFiEEJ7iIR+7gJQEY8+q5LtnXdP5wLbUFAmcWfCgRHHRodXRoQHJl
 ZGhhdC5jb20ACgkQLtnXdP5wLbV6kQ//YwRebyA192IBM+XQK5YYmguieHmWxV8J
 fZf0a1dWN8oiT3jzI48YWttiU9P6AMa/dwiuepVl4G9+d+w1c3RhS6kQqJljNbDb
 NGw+LVZZcwY1FJpEsEwbDfePkugYHmNXUU672kxz3I8bv/8NmLDc7R3cI5U/7+SP
 N4lxVM6Hd3XZZdc+O2S8En20E1oAJ6IvJwwhCqjLlT36Ez8P69KQhE0V8MtLnrBg
 FsXZuzmaxt/ZDMhTsiHNl6f7N1oD7Y2TPJrdq7V2aihpDA+zx0RlvBPpzD98ZgeS
 PtdkqjL63B5S3RL4fjJUSb/gbL4oChQ5TZDb2Dfw7Q5qPMZ1cgeJLBwdzHZEZrzF
 RTtn4fObYUqtRF3M0Ha4xXc8odSzJTV2fvpSVXcljG1E4AMcD6CMK0E472XbhkMS
 txZHW+C/IDVJ4OoSncrH8ybi1JasEqJZ0YaPfb+aTsPV058b65l+0jQJtlxLoTIf
 p5LluL3exwr0sS3Aq5tcV3pNITtCv1FkcUk7So8sohO2OLQtC9QA300CSXna8XhQ
 OxgRA1c3HXw23MTJKSWjseDIt1bajvBu+cr/pmDxlYnWWsSCcEFaAoQohwhOMA6Z
 JfJF0tSv+koUsw6hSl7146aylSvDYUKPilAGgAUAy1yscgglMvtmQqWkEta/XGP2
 U8qvX8nUwOM=
 =DJf9
 -----END PGP SIGNATURE-----

Merge tag 'pull-request-2024-10-21' of https://gitlab.com/thuth/qemu into staging

* Convert most Tuxrun Avocado tests to the new functional framework
* Update the OpenBSD CI image to OpenBSD v7.6
* Bump timeout of the ide-test
* New maintainer for the QTests
* Disable the pci-bridge on s390x by default

# -----BEGIN PGP SIGNATURE-----
#
# iQJFBAABCAAvFiEEJ7iIR+7gJQEY8+q5LtnXdP5wLbUFAmcWfCgRHHRodXRoQHJl
# ZGhhdC5jb20ACgkQLtnXdP5wLbV6kQ//YwRebyA192IBM+XQK5YYmguieHmWxV8J
# fZf0a1dWN8oiT3jzI48YWttiU9P6AMa/dwiuepVl4G9+d+w1c3RhS6kQqJljNbDb
# NGw+LVZZcwY1FJpEsEwbDfePkugYHmNXUU672kxz3I8bv/8NmLDc7R3cI5U/7+SP
# N4lxVM6Hd3XZZdc+O2S8En20E1oAJ6IvJwwhCqjLlT36Ez8P69KQhE0V8MtLnrBg
# FsXZuzmaxt/ZDMhTsiHNl6f7N1oD7Y2TPJrdq7V2aihpDA+zx0RlvBPpzD98ZgeS
# PtdkqjL63B5S3RL4fjJUSb/gbL4oChQ5TZDb2Dfw7Q5qPMZ1cgeJLBwdzHZEZrzF
# RTtn4fObYUqtRF3M0Ha4xXc8odSzJTV2fvpSVXcljG1E4AMcD6CMK0E472XbhkMS
# txZHW+C/IDVJ4OoSncrH8ybi1JasEqJZ0YaPfb+aTsPV058b65l+0jQJtlxLoTIf
# p5LluL3exwr0sS3Aq5tcV3pNITtCv1FkcUk7So8sohO2OLQtC9QA300CSXna8XhQ
# OxgRA1c3HXw23MTJKSWjseDIt1bajvBu+cr/pmDxlYnWWsSCcEFaAoQohwhOMA6Z
# JfJF0tSv+koUsw6hSl7146aylSvDYUKPilAGgAUAy1yscgglMvtmQqWkEta/XGP2
# U8qvX8nUwOM=
# =DJf9
# -----END PGP SIGNATURE-----
# gpg: Signature made Mon 21 Oct 2024 17:07:04 BST
# gpg:                using RSA key 27B88847EEE0250118F3EAB92ED9D774FE702DB5
# gpg:                issuer "thuth@redhat.com"
# gpg: Good signature from "Thomas Huth <th.huth@gmx.de>" [full]
# gpg:                 aka "Thomas Huth <thuth@redhat.com>" [full]
# gpg:                 aka "Thomas Huth <huth@tuxfamily.org>" [full]
# gpg:                 aka "Thomas Huth <th.huth@posteo.de>" [unknown]
# Primary key fingerprint: 27B8 8847 EEE0 2501 18F3  EAB9 2ED9 D774 FE70 2DB5

* tag 'pull-request-2024-10-21' of https://gitlab.com/thuth/qemu:
  tests/functional: Convert the Avocado sh4 tuxrun test
  Revert "hw/sh4/r2d: Realize IDE controller before accessing it"
  tests/functional: Convert the Avocado ppc32 tuxrun test
  tests/functional: Convert the Avocado mips64el tuxrun test
  tests/functional: Convert the Avocado mips64 tuxrun test
  tests/functional: Convert the Avocado mipsel tuxrun test
  tests/functional: Convert the Avocado mips tuxrun test
  tests/functional: Convert the Avocado x86_64 tuxrun test
  tests/functional: Convert the Avocado i386 tuxrun test
  tests/functional: Convert the Avocado riscv64 tuxrun tests
  tests/functional: Convert the Avocado riscv32 tuxrun tests
  tests/functional: Convert the Avocado arm tuxrun tests
  tests/functional: Convert the Avocado s390x tuxrun test
  tests/functional: Convert the Avocado sparc64 tuxrun test
  tests/functional: Convert the Avocado ppc64 tuxrun tests
  tests/functional: Add a base class for the TuxRun tests
  hw/pci-bridge: Add a Kconfig switch for the normal PCI bridge
  MAINTAINERS: A new maintainer for the qtests
  tests/qtest: Raise the ide-test timeout
  tests/vm: update openbsd image to 7.6

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2024-10-21 17:12:59 +01:00
parent 91e4e1832e c592ff3511
commit 6f625ce2f2
23 changed files with 836 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
MAINTAINERS
View File

@ -987,6 +987,7 @@ F: hw/arm/virt*
F: include/hw/arm/virt.h
F: docs/system/arm/virt.rst
F: tests/functional/test_aarch64_virt.py
F: tests/functional/test_arm_tuxrun.py
Xilinx Zynq
M: Edgar E. Iglesias <edgar.iglesias@gmail.com>
@ -1311,9 +1312,8 @@ F: hw/mips/malta.c
F: hw/pci-host/gt64120.c
F: include/hw/southbridge/piix.h
F: tests/avocado/linux_ssh_mips_malta.py
F: tests/functional/test_mips_malta.py
F: tests/functional/test_mipsel_malta.py
F: tests/functional/test_mips64el_malta.py
F: tests/functional/test_mips*_malta.py
F: tests/functional/test_mips*_tuxrun.py
Mipssim
R: Aleksandar Rikalo <arikalo@gmail.com>
@ -1396,6 +1396,7 @@ F: hw/intc/openpic_kvm.c
F: include/hw/ppc/openpic_kvm.h
F: docs/system/ppc/ppce500.rst
F: tests/functional/test_ppc64_e500.py
F: tests/functional/test_ppc_tuxrun.py
mpc8544ds
M: Bernhard Beschow <shentey@gmail.com>
@ -1484,6 +1485,7 @@ F: tests/qtest/rtas*
F: tests/qtest/libqos/rtas*
F: tests/functional/test_ppc64_pseries.py
F: tests/functional/test_ppc64_hv.py
F: tests/functional/test_ppc64_tuxrun.py
PowerNV (Non-Virtualized)
M: Cédric Le Goater <clg@kaod.org>
@ -1631,6 +1633,7 @@ F: hw/timer/sh_timer.c
F: include/hw/sh4/sh_intc.h
F: include/hw/timer/tmu012.h
F: tests/functional/test_sh4_r2d.py
F: tests/functional/test_sh4_tuxrun.py
SPARC Machines
--------------
@ -1662,6 +1665,7 @@ F: hw/pci-bridge/simba.c
F: include/hw/pci-bridge/simba.h
F: pc-bios/openbios-sparc64
F: tests/functional/test_sparc64_sun4u.py
F: tests/functional/test_sparc64_tuxrun.py
Sun4v
M: Artyom Tarasenko <atar4qemu@gmail.com>
@ -1688,7 +1692,7 @@ S: Supported
F: hw/s390x/
F: include/hw/s390x/
F: configs/devices/s390x-softmmu/default.mak
F: tests/functional/test_s390x_ccw_virtio.py
F: tests/functional/test_s390x_*
T: git https://github.com/borntraeger/qemu.git s390-next
L: qemu-s390x@nongnu.org
@ -1779,8 +1783,10 @@ F: hw/isa/apm.c
F: include/hw/isa/apm.h
F: tests/unit/test-x86-topo.c
F: tests/qtest/test-x86-cpuid-compat.c
F: tests/functional/test_i386_tuxrun.py
F: tests/functional/test_mem_addr_space.py
F: tests/functional/test_pc_cpu_hotplug_props.py
F: tests/functional/test_x86_64_tuxrun.py
F: tests/functional/test_x86_cpu_model_versions.py
PC Chipset
@ -3259,7 +3265,7 @@ F: tests/qtest/qmp-cmd-test.c
T: git https://repo.or.cz/qemu/armbru.git qapi-next
qtest
M: Thomas Huth <thuth@redhat.com>
M: Fabiano Rosas <farosas@suse.de>
M: Laurent Vivier <lvivier@redhat.com>
R: Paolo Bonzini <pbonzini@redhat.com>
S: Maintained
@ -3277,7 +3283,7 @@ M: Alexander Bulekov <alxndr@bu.edu>
R: Paolo Bonzini <pbonzini@redhat.com>
R: Bandan Das <bsd@redhat.com>
R: Stefan Hajnoczi <stefanha@redhat.com>
R: Thomas Huth <thuth@redhat.com>
R: Fabiano Rosas <farosas@suse.de>
R: Darren Kenny <darren.kenny@oracle.com>
R: Qiuhao Li <Qiuhao.Li@outlook.com>
S: Maintained

5
hw/pci-bridge/Kconfig
View File

@ -1,3 +1,8 @@
config PCI_BRIDGE
bool
default y if PCI_DEVICES
depends on PCI
config PCIE_PORT
bool
default y if PCI_DEVICES

2
hw/pci-bridge/meson.build
View File

@ -1,5 +1,5 @@
pci_ss = ss.source_set()
pci_ss.add(files('pci_bridge_dev.c'))
pci_ss.add(when: 'CONFIG_PCI_BRIDGE', if_true: files('pci_bridge_dev.c'))
pci_ss.add(when: 'CONFIG_I82801B11', if_true: files('i82801b11.c'))
pci_ss.add(when: 'CONFIG_IOH3420', if_true: files('ioh3420.c'))
pci_ss.add(when: 'CONFIG_PCIE_PORT', if_true: files('pcie_root_port.c', 'gen_pcie_root_port.c'))

2
hw/sh4/r2d.c
View File

@ -286,9 +286,9 @@ static void r2d_init(MachineState *machine)
dinfo = drive_get(IF_IDE, 0, 0);
dev = qdev_new("mmio-ide");
busdev = SYS_BUS_DEVICE(dev);
sysbus_connect_irq(busdev, 0, irq[CF_IDE]);
qdev_prop_set_uint32(dev, "shift", 1);
sysbus_realize_and_unref(busdev, &error_fatal);
sysbus_connect_irq(busdev, 0, irq[CF_IDE]);
sysbus_mmio_map(busdev, 0, 0x14001000);
sysbus_mmio_map(busdev, 1, 0x1400080c);
mmio_ide_init_drives(dev, dinfo, NULL);

396
tests/avocado/tuxrun_baselines.py
View File

@ -182,63 +182,6 @@ class TuxRunBaselineTest(QemuSystemTest):
self.vm.launch()
self.run_tuxtest_tests(haltmsg)
def ppc64_common_tuxrun(self, sums, prefix):
# add device args to command line.
self.require_netdev('user')
self.vm.add_args('-netdev', 'user,id=vnet,hostfwd=:127.0.0.1:0-:22',
'-device', 'virtio-net,netdev=vnet')
self.vm.add_args('-netdev', '{"type":"user","id":"hostnet0"}',
'-device', '{"driver":"virtio-net-pci","netdev":'
'"hostnet0","id":"net0","mac":"52:54:00:4c:e3:86",'
'"bus":"pci.0","addr":"0x9"}')
self.vm.add_args('-device', '{"driver":"qemu-xhci","p2":15,"p3":15,'
'"id":"usb","bus":"pci.0","addr":"0x2"}')
self.vm.add_args('-device', '{"driver":"virtio-scsi-pci","id":"scsi0"'
',"bus":"pci.0","addr":"0x3"}')
self.vm.add_args('-device', '{"driver":"virtio-serial-pci","id":'
'"virtio-serial0","bus":"pci.0","addr":"0x4"}')
self.vm.add_args('-device', '{"driver":"scsi-cd","bus":"scsi0.0"'
',"channel":0,"scsi-id":0,"lun":0,"device_id":'
'"drive-scsi0-0-0-0","id":"scsi0-0-0-0"}')
self.vm.add_args('-device', '{"driver":"virtio-balloon-pci",'
'"id":"balloon0","bus":"pci.0","addr":"0x6"}')
self.vm.add_args('-audiodev', '{"id":"audio1","driver":"none"}')
self.vm.add_args('-device', '{"driver":"usb-tablet","id":"input0"'
',"bus":"usb.0","port":"1"}')
self.vm.add_args('-device', '{"driver":"usb-kbd","id":"input1"'
',"bus":"usb.0","port":"2"}')
self.vm.add_args('-device', '{"driver":"VGA","id":"video0",'
'"vgamem_mb":16,"bus":"pci.0","addr":"0x7"}')
self.vm.add_args('-object', '{"qom-type":"rng-random","id":"objrng0"'
',"filename":"/dev/urandom"}',
'-device', '{"driver":"virtio-rng-pci","rng":"objrng0"'
',"id":"rng0","bus":"pci.0","addr":"0x8"}')
self.vm.add_args('-object', '{"qom-type":"cryptodev-backend-builtin",'
'"id":"objcrypto0","queues":1}',
'-device', '{"driver":"virtio-crypto-pci",'
'"cryptodev":"objcrypto0","id":"crypto0","bus"'
':"pci.0","addr":"0xa"}')
self.vm.add_args('-device', '{"driver":"spapr-pci-host-bridge"'
',"index":1,"id":"pci.1"}')
self.vm.add_args('-device', '{"driver":"spapr-vscsi","id":"scsi1"'
',"reg":12288}')
self.vm.add_args('-m', '2G,slots=32,maxmem=4G',
'-object', 'memory-backend-ram,id=ram1,size=1G',
'-device', 'pc-dimm,id=dimm1,memdev=ram1')
# Create a temporary qcow2 and launch the test-case
with tempfile.NamedTemporaryFile(prefix=prefix,
suffix='.qcow2') as qcow2:
process.run(self.qemu_img + ' create -f qcow2 ' +
qcow2.name + ' 1G')
self.vm.add_args('-drive', 'file=' + qcow2.name +
',format=qcow2,if=none,id='
'drive-virtio-disk1',
'-device', 'virtio-blk-pci,bus=pci.0,'
'addr=0xb,drive=drive-virtio-disk1,id=virtio-disk1'
',bootindex=2')
self.common_tuxrun(csums=sums, drive="scsi-hd")
#
# The tests themselves. The configuration is derived from how
@ -279,342 +222,3 @@ class TuxRunBaselineTest(QemuSystemTest):
"rootfs.ext4.zst" :
"e6ffd8813c8a335bc15728f2835f90539c84be7f8f5f691a8b01451b47fb4bd7"}
self.common_tuxrun(csums=sums)
def test_armv5(self):
"""
:avocado: tags=arch:arm
:avocado: tags=cpu:arm926
:avocado: tags=machine:versatilepb
:avocado: tags=tuxboot:armv5
:avocado: tags=image:zImage
:avocado: tags=console:ttyAMA0
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"17177afa74e7294da0642861f08c88ca3c836764299a54bf6d1ce276cb9712a5",
"versatile-pb.dtb" :
"0bc0c0b0858cefd3c32b385c0d66d97142ded29472a496f4f490e42fc7615b25",
"zImage" :
"c95af2f27647c12265d75e9df44c22ff5228c59855f54aaa70f41ec2842e3a4d" }
self.common_tuxrun(csums=sums,
drive="virtio-blk-pci",
dt="versatile-pb.dtb")
def test_armv7(self):
"""
:avocado: tags=arch:arm
:avocado: tags=cpu:cortex-a15
:avocado: tags=machine:virt
:avocado: tags=tuxboot:armv7
:avocado: tags=image:zImage
:avocado: tags=console:ttyAMA0
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"ab1fbbeaddda1ffdd45c9405a28cd5370c20f23a7cbc809cc90dc9f243a8eb5a",
"zImage" :
"4c7a22e9f15875bec06bd2a29d822496571eb297d4f22694099ffcdb19077572" }
self.common_tuxrun(csums=sums)
def test_armv7be(self):
"""
:avocado: tags=arch:arm
:avocado: tags=cpu:cortex-a15
:avocado: tags=endian:big
:avocado: tags=machine:virt
:avocado: tags=tuxboot:armv7be
:avocado: tags=image:zImage
:avocado: tags=console:ttyAMA0
:avocado: tags=shutdown:nowait
"""
sums = {"rootfs.ext4.zst" :
"42ed46dd2d59986206c5b1f6cf35eab58fe3fd20c96b41aaa16b32f3f90a9835",
"zImage" :
"7facc62082b57af12015b08f7fdbaf2f123ba07a478367853ae12b219afc9f2f" }
self.common_tuxrun(csums=sums)
def test_i386(self):
"""
:avocado: tags=arch:i386
:avocado: tags=cpu:coreduo
:avocado: tags=machine:q35
:avocado: tags=tuxboot:i386
:avocado: tags=image:bzImage
:avocado: tags=shutdown:nowait
"""
sums = {"bzImage" :
"a3e5b32a354729e65910f5a1ffcda7c14a6c12a55e8213fb86e277f1b76ed956",
"rootfs.ext4.zst" :
"f15e66b2bf673a210ec2a4b2e744a80530b36289e04f5388aab812b97f69754a" }
self.common_tuxrun(csums=sums, drive="virtio-blk-pci")
def test_mips32(self):
"""
:avocado: tags=arch:mips
:avocado: tags=machine:malta
:avocado: tags=cpu:mips32r6-generic
:avocado: tags=endian:big
:avocado: tags=tuxboot:mips32
:avocado: tags=image:vmlinux
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"fc3da0b4c2f38d74c6d705123bb0f633c76ed953128f9d0859378c328a6d11a0",
"vmlinux" :
"bfd2172f8b17fb32970ca0c8c58f59c5a4ca38aa5855d920be3a69b5d16e52f0" }
self.common_tuxrun(csums=sums, drive="driver=ide-hd,bus=ide.0,unit=0")
def test_mips32el(self):
"""
:avocado: tags=arch:mipsel
:avocado: tags=machine:malta
:avocado: tags=cpu:mips32r6-generic
:avocado: tags=tuxboot:mips32el
:avocado: tags=image:vmlinux
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"e799768e289fd69209c21f4dacffa11baea7543d5db101e8ce27e3bc2c41d90e",
"vmlinux" :
"8573867c68a8443db8de6d08bb33fb291c189ca2ca671471d3973a3e712096a3" }
self.common_tuxrun(csums=sums, drive="driver=ide-hd,bus=ide.0,unit=0")
def test_mips64(self):
"""
:avocado: tags=arch:mips64
:avocado: tags=machine:malta
:avocado: tags=tuxboot:mips64
:avocado: tags=endian:big
:avocado: tags=image:vmlinux
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"69d91eeb04df3d8d172922c6993bb37d4deeb6496def75d8580f6f9de3e431da",
"vmlinux" :
"09010e51e4b8bcbbd2494786ffb48eca78f228e96e5c5438344b0eac4029dc61" }
self.common_tuxrun(csums=sums, drive="driver=ide-hd,bus=ide.0,unit=0")
def test_mips64el(self):
"""
:avocado: tags=arch:mips64el
:avocado: tags=machine:malta
:avocado: tags=tuxboot:mips64el
:avocado: tags=image:vmlinux
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"fba585368f5915b1498ed081863474b2d7ec4e97cdd46d21bdcb2f9698f83de4",
"vmlinux" :
"d4e08965e2155c4cccce7c5f34d18fe34c636cda2f2c9844387d614950155266" }
self.common_tuxrun(csums=sums, drive="driver=ide-hd,bus=ide.0,unit=0")
def test_ppc32(self):
"""
:avocado: tags=arch:ppc
:avocado: tags=machine:ppce500
:avocado: tags=cpu:e500mc
:avocado: tags=tuxboot:ppc32
:avocado: tags=image:uImage
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"8885b9d999cc24d679542a02e9b6aaf48f718f2050ece6b8347074b6ee41dd09",
"uImage" :
"1a68f74b860fda022fb12e03c5efece8c2b8b590d96cca37a8481a3ae0b3f81f" }
self.common_tuxrun(csums=sums, drive="virtio-blk-pci")
def test_ppc64(self):
"""
:avocado: tags=arch:ppc64
:avocado: tags=machine:pseries
:avocado: tags=cpu:POWER10
:avocado: tags=endian:big
:avocado: tags=console:hvc0
:avocado: tags=tuxboot:ppc64
:avocado: tags=image:vmlinux
:avocado: tags=extradev:driver=spapr-vscsi
:avocado: tags=root:sda
"""
sums = { "rootfs.ext4.zst" :
"1d953e81a4379e537fc8e41e05a0a59d9b453eef97aa03d47866c6c45b00bdff",
"vmlinux" :
"f22a9b9e924174a4c199f4c7e5d91a2339fcfe51c6eafd0907dc3e09b64ab728" }
self.ppc64_common_tuxrun(sums, prefix='tuxrun_ppc64_')
def test_ppc64le(self):
"""
:avocado: tags=arch:ppc64
:avocado: tags=machine:pseries
:avocado: tags=cpu:POWER10
:avocado: tags=console:hvc0
:avocado: tags=tuxboot:ppc64le
:avocado: tags=image:vmlinux
:avocado: tags=extradev:driver=spapr-vscsi
:avocado: tags=root:sda
"""
sums = { "rootfs.ext4.zst" :
"b442678c93fb8abe1f7d3bfa20556488de6b475c22c8fed363f42cf81a0a3906",
"vmlinux" :
"979eb61b445a010fb13e2b927126991f8ceef9c590fa2be0996c00e293e80cf2" }
self.ppc64_common_tuxrun(sums, prefix='tuxrun_ppc64le_')
def test_riscv32(self):
"""
:avocado: tags=arch:riscv32
:avocado: tags=machine:virt
:avocado: tags=tuxboot:riscv32
"""
sums = { "Image" :
"89599407d7334de629a40e7ad6503c73670359eb5f5ae9d686353a3d6deccbd5",
"fw_jump.elf" :
"f2ef28a0b77826f79d085d3e4aa686f1159b315eff9099a37046b18936676985",
"rootfs.ext4.zst" :
"7168d296d0283238ea73cd5a775b3dd608e55e04c7b92b76ecce31bb13108cba" }
self.common_tuxrun(csums=sums)
def test_riscv64(self):
"""
:avocado: tags=arch:riscv64
:avocado: tags=machine:virt
:avocado: tags=tuxboot:riscv64
"""
sums = { "Image" :
"cd634badc65e52fb63465ec99e309c0de0369f0841b7d9486f9729e119bac25e",
"fw_jump.elf" :
"6e3373abcab4305fe151b564a4c71110d833c21f2c0a1753b7935459e36aedcf",
"rootfs.ext4.zst" :
"b18e3a3bdf27be03da0b285e84cb71bf09eca071c3a087b42884b6982ed679eb" }
self.common_tuxrun(csums=sums)
def test_riscv32_maxcpu(self):
"""
:avocado: tags=arch:riscv32
:avocado: tags=machine:virt
:avocado: tags=cpu:max
:avocado: tags=tuxboot:riscv32
"""
sums = { "Image" :
"89599407d7334de629a40e7ad6503c73670359eb5f5ae9d686353a3d6deccbd5",
"fw_jump.elf" :
"f2ef28a0b77826f79d085d3e4aa686f1159b315eff9099a37046b18936676985",
"rootfs.ext4.zst" :
"7168d296d0283238ea73cd5a775b3dd608e55e04c7b92b76ecce31bb13108cba" }
self.common_tuxrun(csums=sums)
def test_riscv64_maxcpu(self):
"""
:avocado: tags=arch:riscv64
:avocado: tags=machine:virt
:avocado: tags=cpu:max
:avocado: tags=tuxboot:riscv64
"""
sums = { "Image" :
"cd634badc65e52fb63465ec99e309c0de0369f0841b7d9486f9729e119bac25e",
"fw_jump.elf" :
"6e3373abcab4305fe151b564a4c71110d833c21f2c0a1753b7935459e36aedcf",
"rootfs.ext4.zst" :
"b18e3a3bdf27be03da0b285e84cb71bf09eca071c3a087b42884b6982ed679eb" }
self.common_tuxrun(csums=sums)
def test_s390(self):
"""
:avocado: tags=arch:s390x
:avocado: tags=endian:big
:avocado: tags=tuxboot:s390
:avocado: tags=image:bzImage
:avocado: tags=shutdown:nowait
"""
sums = { "bzImage" :
"0414e98dd1c3dafff8496c9cd9c28a5f8d04553bb5ba37e906a812b48d442ef0",
"rootfs.ext4.zst" :
"88c37c32276677f873a25ab9ec6247895b8e3e6f8259134de2a616080b8ab3fc" }
self.common_tuxrun(csums=sums,
drive="virtio-blk-ccw",
haltmsg="Requesting system halt")
# Note: some segfaults caused by unaligned userspace access
@skipUnless(os.getenv('QEMU_TEST_FLAKY_TESTS'), 'Test is unstable on GitLab')
def test_sh4(self):
"""
:avocado: tags=arch:sh4
:avocado: tags=machine:r2d
:avocado: tags=cpu:sh7785
:avocado: tags=tuxboot:sh4
:avocado: tags=image:zImage
:avocado: tags=root:sda
:avocado: tags=console:ttySC1
:avocado: tags=flaky
"""
sums = { "rootfs.ext4.zst" :
"3592a7a3d5a641e8b9821449e77bc43c9904a56c30d45da0694349cfd86743fd",
"zImage" :
"29d9b2aba604a0f53a5dc3b5d0f2b8e35d497de1129f8ee5139eb6fdf0db692f" }
# The test is currently too unstable to do much in userspace
# so we skip common_tuxrun and do a minimal boot and shutdown.
(kernel, disk, dtb) = self.fetch_tuxrun_assets(csums=sums)
# the console comes on the second serial port
self.prepare_run(kernel, disk,
"driver=ide-hd,bus=ide.0,unit=0",
console_index=1)
self.vm.launch()
self.wait_for_console_pattern("Welcome to TuxTest")
time.sleep(0.1)
exec_command(self, 'root')
time.sleep(0.1)
exec_command_and_wait_for_pattern(self, 'halt',
"reboot: System halted")
def test_sparc64(self):
"""
:avocado: tags=arch:sparc64
:avocado: tags=tuxboot:sparc64
:avocado: tags=image:vmlinux
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "rootfs.ext4.zst" :
"ad2f1dc436ab51583543d25d2c210cab478645d47078d30d129a66ab0e281d76",
"vmlinux" :
"e34313e4325ff21deaa3d38a502aa09a373ef62b9bd4d7f8f29388b688225c55" }
self.common_tuxrun(csums=sums, drive="driver=ide-hd,bus=ide.0,unit=0")
def test_x86_64(self):
"""
:avocado: tags=arch:x86_64
:avocado: tags=machine:q35
:avocado: tags=cpu:Nehalem
:avocado: tags=tuxboot:x86_64
:avocado: tags=image:bzImage
:avocado: tags=root:sda
:avocado: tags=shutdown:nowait
"""
sums = { "bzImage" :
"2bc7480a669ee9b6b82500a236aba0c54233debe98cb968268fa230f52f03461",
"rootfs.ext4.zst" :
"b72ac729769b8f51c6dffb221113c9a063c774dbe1d66af30eb593c4e9999b4b" }
self.common_tuxrun(csums=sums,
drive="driver=ide-hd,bus=ide.0,unit=0")

26
tests/functional/meson.build
View File

@ -16,6 +16,7 @@ test_timeouts = {
'aarch64_virt' : 360,
'acpi_bits' : 240,
'arm_raspi2' : 120,
'arm_tuxrun' : 120,
'mips_malta' : 120,
'netdev_ethtool' : 180,
'ppc_40p' : 240,
@ -54,6 +55,7 @@ tests_arm_system_thorough = [
'arm_integratorcp',
'arm_raspi2',
'arm_vexpress',
'arm_tuxrun',
]
tests_arm_linuxuser_thorough = [
@ -64,6 +66,10 @@ tests_avr_system_thorough = [
'avr_mega2560',
]
tests_i386_system_thorough = [
'i386_tuxrun',
]
tests_loongarch64_system_thorough = [
'loongarch64_virt',
]
@ -84,16 +90,23 @@ tests_microblazeel_system_thorough = [
tests_mips_system_thorough = [
'mips_malta',
'mips_tuxrun',
]
tests_mipsel_system_thorough = [
'mipsel_malta',
'mipsel_tuxrun',
]
tests_mips64_system_thorough = [
'mips64_tuxrun',
]
tests_mips64el_system_thorough = [
'mips64el_fuloong2e',
'mips64el_loongson3v',
'mips64el_malta',
'mips64el_tuxrun',
]
tests_or1k_system_thorough = [
@ -111,6 +124,7 @@ tests_ppc_system_thorough = [
'ppc_bamboo',
'ppc_mac',
'ppc_mpc8544ds',
'ppc_tuxrun',
'ppc_virtex_ml507',
]
@ -125,6 +139,14 @@ tests_rx_system_thorough = [
'rx_gdbsim',
]
tests_riscv32_system_thorough = [
'riscv32_tuxrun',
]
tests_riscv64_system_thorough = [
'riscv64_tuxrun',
]
tests_s390x_system_thorough = [
's390x_ccw_virtio',
's390x_topology',
@ -132,14 +154,17 @@ tests_s390x_system_thorough = [
tests_sh4_system_thorough = [
'sh4_r2d',
'sh4_tuxrun',
]
tests_sparc_system_thorough = [
'sparc_sun4m',
]
tests_sparc64_system_thorough = [
'sparc64_sun4u',
'sparc64_tuxrun',
]
tests_x86_64_system_quick = [
@ -152,6 +177,7 @@ tests_x86_64_system_quick = [
tests_x86_64_system_thorough = [
'acpi_bits',
'x86_64_tuxrun',
'linux_initrd',
'multiprocess',
'netdev_ethtool',

158
tests/functional/qemu_test/tuxruntest.py Normal file
View File

@ -0,0 +1,158 @@
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import time
from qemu_test import QemuSystemTest
from qemu_test import exec_command, exec_command_and_wait_for_pattern
from qemu_test import wait_for_console_pattern
from qemu_test import has_cmd, run_cmd, get_qemu_img
class TuxRunBaselineTest(QemuSystemTest):
KERNEL_COMMON_COMMAND_LINE = 'printk.time=0'
# Tests are ~10-40s, allow for --debug/--enable-gcov overhead
timeout = 100
def get_tag(self, tagname, default=None):
"""
Get the metadata tag or return the default.
"""
utag = self._get_unique_tag_val(tagname)
print(f"{tagname}/{default} -> {utag}")
if utag:
return utag
return default
def setUp(self):
super().setUp()
# We need zstd for all the tuxrun tests
# See https://github.com/avocado-framework/avocado/issues/5609
(has_zstd, msg) = has_cmd('zstd')
if has_zstd is False:
self.skipTest(msg)
self.zstd = 'zstd'
# Pre-init TuxRun specific settings: Most machines work with
# reasonable defaults but we sometimes need to tweak the
# config. To avoid open coding everything we store all these
# details in the metadata for each test.
# The tuxboot tag matches the root directory
self.tuxboot = self.arch
# Most Linux's use ttyS0 for their serial port
self.console = "ttyS0"
# Does the machine shutdown QEMU nicely on "halt"
self.wait_for_shutdown = True
self.root = "vda"
# Occasionally we need extra devices to hook things up
self.extradev = None
self.qemu_img = get_qemu_img(self)
def wait_for_console_pattern(self, success_message, vm=None):
wait_for_console_pattern(self, success_message,
failure_message='Kernel panic - not syncing',
vm=vm)
def fetch_tuxrun_assets(self, kernel_asset, rootfs_asset, dtb_asset=None):
"""
Fetch the TuxBoot assets.
"""
kernel_image = kernel_asset.fetch()
disk_image_zst = rootfs_asset.fetch()
run_cmd([self.zstd, "-f", "-d", disk_image_zst,
"-o", self.workdir + "/rootfs.ext4"])
dtb = dtb_asset.fetch() if dtb_asset is not None else None
return (kernel_image, self.workdir + "/rootfs.ext4", dtb)
def prepare_run(self, kernel, disk, drive, dtb=None, console_index=0):
"""
Setup to run and add the common parameters to the system
"""
self.vm.set_console(console_index=console_index)
# all block devices are raw ext4's
blockdev = "driver=raw,file.driver=file," \
+ f"file.filename={disk},node-name=hd0"
kcmd_line = self.KERNEL_COMMON_COMMAND_LINE
kcmd_line += f" root=/dev/{self.root}"
kcmd_line += f" console={self.console}"
self.vm.add_args('-kernel', kernel,
'-append', kcmd_line,
'-blockdev', blockdev)
# Sometimes we need extra devices attached
if self.extradev:
self.vm.add_args('-device', self.extradev)
self.vm.add_args('-device',
f"{drive},drive=hd0")
# Some machines need an explicit DTB
if dtb:
self.vm.add_args('-dtb', dtb)
def run_tuxtest_tests(self, haltmsg):
"""
Wait for the system to boot up, wait for the login prompt and
then do a few things on the console. Trigger a shutdown and
wait to exit cleanly.
"""
self.wait_for_console_pattern("Welcome to TuxTest")
time.sleep(0.2)
exec_command(self, 'root')
time.sleep(0.2)
exec_command(self, 'cat /proc/interrupts')
time.sleep(0.1)
exec_command(self, 'cat /proc/self/maps')
time.sleep(0.1)
exec_command(self, 'uname -a')
time.sleep(0.1)
exec_command_and_wait_for_pattern(self, 'halt', haltmsg)
# Wait for VM to shut down gracefully if it can
if self.wait_for_shutdown:
self.vm.wait()
else:
self.vm.shutdown()
def common_tuxrun(self,
kernel_asset,
rootfs_asset,
dtb_asset=None,
drive="virtio-blk-device",
haltmsg="reboot: System halted",
console_index=0):
"""
Common path for LKFT tests. Unless we need to do something
special with the command line we can process most things using
the tag metadata.
"""
(kernel, disk, dtb) = self.fetch_tuxrun_assets(kernel_asset, rootfs_asset,
dtb_asset)
self.prepare_run(kernel, disk, drive, dtb, console_index)
self.vm.launch()
self.run_tuxtest_tests(haltmsg)
os.remove(disk)

70
tests/functional/test_arm_tuxrun.py Executable file
View File

@ -0,0 +1,70 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunArmTest(TuxRunBaselineTest):
ASSET_ARMV5_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/armv5/zImage',
'c95af2f27647c12265d75e9df44c22ff5228c59855f54aaa70f41ec2842e3a4d')
ASSET_ARMV5_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/armv5/rootfs.ext4.zst',
'17177afa74e7294da0642861f08c88ca3c836764299a54bf6d1ce276cb9712a5')
ASSET_ARMV5_DTB = Asset(
'https://storage.tuxboot.com/20230331/armv5/versatile-pb.dtb',
'0bc0c0b0858cefd3c32b385c0d66d97142ded29472a496f4f490e42fc7615b25')
def test_armv5(self):
self.set_machine('versatilepb')
self.cpu='arm926'
self.console='ttyAMA0'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_ARMV5_KERNEL,
rootfs_asset=self.ASSET_ARMV5_ROOTFS,
dtb_asset=self.ASSET_ARMV5_DTB,
drive="virtio-blk-pci")
ASSET_ARMV7_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/armv7/zImage',
'4c7a22e9f15875bec06bd2a29d822496571eb297d4f22694099ffcdb19077572')
ASSET_ARMV7_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/armv7/rootfs.ext4.zst',
'ab1fbbeaddda1ffdd45c9405a28cd5370c20f23a7cbc809cc90dc9f243a8eb5a')
def test_armv7(self):
self.set_machine('virt')
self.cpu='cortex-a15'
self.console='ttyAMA0'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_ARMV7_KERNEL,
rootfs_asset=self.ASSET_ARMV7_ROOTFS)
ASSET_ARMV7BE_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/armv7be/zImage',
'7facc62082b57af12015b08f7fdbaf2f123ba07a478367853ae12b219afc9f2f')
ASSET_ARMV7BE_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/armv7be/rootfs.ext4.zst',
'42ed46dd2d59986206c5b1f6cf35eab58fe3fd20c96b41aaa16b32f3f90a9835')
def test_armv7be(self):
self.set_machine('virt')
self.cpu='cortex-a15'
self.console='ttyAMA0'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_ARMV7BE_KERNEL,
rootfs_asset=self.ASSET_ARMV7BE_ROOTFS)
if __name__ == '__main__':
TuxRunBaselineTest.main()

35
tests/functional/test_i386_tuxrun.py Executable file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunI386Test(TuxRunBaselineTest):
ASSET_I386_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/i386/bzImage',
'a3e5b32a354729e65910f5a1ffcda7c14a6c12a55e8213fb86e277f1b76ed956')
ASSET_I386_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/i386/rootfs.ext4.zst',
'f15e66b2bf673a210ec2a4b2e744a80530b36289e04f5388aab812b97f69754a')
def test_i386(self):
self.set_machine('q35')
self.cpu="coreduo"
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_I386_KERNEL,
rootfs_asset=self.ASSET_I386_ROOTFS,
drive="virtio-blk-pci")
if __name__ == '__main__':
TuxRunBaselineTest.main()

35
tests/functional/test_mips64_tuxrun.py Executable file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunMips64Test(TuxRunBaselineTest):
ASSET_MIPS64_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/mips64/vmlinux',
'09010e51e4b8bcbbd2494786ffb48eca78f228e96e5c5438344b0eac4029dc61')
ASSET_MIPS64_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/mips64/rootfs.ext4.zst',
'69d91eeb04df3d8d172922c6993bb37d4deeb6496def75d8580f6f9de3e431da')
def test_mips64(self):
self.set_machine('malta')
self.root="sda"
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_MIPS64_KERNEL,
rootfs_asset=self.ASSET_MIPS64_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

35
tests/functional/test_mips64el_tuxrun.py Executable file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunMips64ELTest(TuxRunBaselineTest):
ASSET_MIPS64EL_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/mips64el/vmlinux',
'd4e08965e2155c4cccce7c5f34d18fe34c636cda2f2c9844387d614950155266')
ASSET_MIPS64EL_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/mips64el/rootfs.ext4.zst',
'fba585368f5915b1498ed081863474b2d7ec4e97cdd46d21bdcb2f9698f83de4')
def test_mips64el(self):
self.set_machine('malta')
self.root="sda"
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_MIPS64EL_KERNEL,
rootfs_asset=self.ASSET_MIPS64EL_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

36
tests/functional/test_mips_tuxrun.py Executable file
View File

@ -0,0 +1,36 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunMipsTest(TuxRunBaselineTest):
ASSET_MIPS_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/mips32/vmlinux',
'bfd2172f8b17fb32970ca0c8c58f59c5a4ca38aa5855d920be3a69b5d16e52f0')
ASSET_MIPS_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/mips32/rootfs.ext4.zst',
'fc3da0b4c2f38d74c6d705123bb0f633c76ed953128f9d0859378c328a6d11a0')
def test_mips32(self):
self.set_machine('malta')
self.cpu="mips32r6-generic"
self.root="sda"
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_MIPS_KERNEL,
rootfs_asset=self.ASSET_MIPS_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

36
tests/functional/test_mipsel_tuxrun.py Executable file
View File

@ -0,0 +1,36 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunMipsELTest(TuxRunBaselineTest):
ASSET_MIPSEL_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/mips32el/vmlinux',
'8573867c68a8443db8de6d08bb33fb291c189ca2ca671471d3973a3e712096a3')
ASSET_MIPSEL_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/mips32el/rootfs.ext4.zst',
'e799768e289fd69209c21f4dacffa11baea7543d5db101e8ce27e3bc2c41d90e')
def test_mips32el(self):
self.set_machine('malta')
self.cpu="mips32r6-generic"
self.root="sda"
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_MIPSEL_KERNEL,
rootfs_asset=self.ASSET_MIPSEL_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

110
tests/functional/test_ppc64_tuxrun.py Executable file
View File

@ -0,0 +1,110 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
import tempfile
from qemu_test import run_cmd, Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunPPC64Test(TuxRunBaselineTest):
def ppc64_common_tuxrun(self, kernel_asset, rootfs_asset, prefix):
self.set_machine('pseries')
self.cpu='POWER10'
self.console='hvc0'
self.root='sda'
self.extradev='spapr-vscsi'
# add device args to command line.
self.require_netdev('user')
self.vm.add_args('-netdev', 'user,id=vnet,hostfwd=:127.0.0.1:0-:22',
'-device', 'virtio-net,netdev=vnet')
self.vm.add_args('-netdev', '{"type":"user","id":"hostnet0"}',
'-device', '{"driver":"virtio-net-pci","netdev":'
'"hostnet0","id":"net0","mac":"52:54:00:4c:e3:86",'
'"bus":"pci.0","addr":"0x9"}')
self.vm.add_args('-device', '{"driver":"qemu-xhci","p2":15,"p3":15,'
'"id":"usb","bus":"pci.0","addr":"0x2"}')
self.vm.add_args('-device', '{"driver":"virtio-scsi-pci","id":"scsi0"'
',"bus":"pci.0","addr":"0x3"}')
self.vm.add_args('-device', '{"driver":"virtio-serial-pci","id":'
'"virtio-serial0","bus":"pci.0","addr":"0x4"}')
self.vm.add_args('-device', '{"driver":"scsi-cd","bus":"scsi0.0"'
',"channel":0,"scsi-id":0,"lun":0,"device_id":'
'"drive-scsi0-0-0-0","id":"scsi0-0-0-0"}')
self.vm.add_args('-device', '{"driver":"virtio-balloon-pci",'
'"id":"balloon0","bus":"pci.0","addr":"0x6"}')
self.vm.add_args('-audiodev', '{"id":"audio1","driver":"none"}')
self.vm.add_args('-device', '{"driver":"usb-tablet","id":"input0"'
',"bus":"usb.0","port":"1"}')
self.vm.add_args('-device', '{"driver":"usb-kbd","id":"input1"'
',"bus":"usb.0","port":"2"}')
self.vm.add_args('-device', '{"driver":"VGA","id":"video0",'
'"vgamem_mb":16,"bus":"pci.0","addr":"0x7"}')
self.vm.add_args('-object', '{"qom-type":"rng-random","id":"objrng0"'
',"filename":"/dev/urandom"}',
'-device', '{"driver":"virtio-rng-pci","rng":"objrng0"'
',"id":"rng0","bus":"pci.0","addr":"0x8"}')
self.vm.add_args('-object', '{"qom-type":"cryptodev-backend-builtin",'
'"id":"objcrypto0","queues":1}',
'-device', '{"driver":"virtio-crypto-pci",'
'"cryptodev":"objcrypto0","id":"crypto0","bus"'
':"pci.0","addr":"0xa"}')
self.vm.add_args('-device', '{"driver":"spapr-pci-host-bridge"'
',"index":1,"id":"pci.1"}')
self.vm.add_args('-device', '{"driver":"spapr-vscsi","id":"scsi1"'
',"reg":12288}')
self.vm.add_args('-m', '2G,slots=32,maxmem=4G',
'-object', 'memory-backend-ram,id=ram1,size=1G',
'-device', 'pc-dimm,id=dimm1,memdev=ram1')
# Create a temporary qcow2 and launch the test-case
with tempfile.NamedTemporaryFile(prefix=prefix,
suffix='.qcow2') as qcow2:
run_cmd([self.qemu_img, 'create', '-f', 'qcow2', qcow2.name, ' 1G'])
self.vm.add_args('-drive', 'file=' + qcow2.name +
',format=qcow2,if=none,id='
'drive-virtio-disk1',
'-device', 'virtio-blk-pci,bus=pci.0,'
'addr=0xb,drive=drive-virtio-disk1,id=virtio-disk1'
',bootindex=2')
self.common_tuxrun(kernel_asset, rootfs_asset=rootfs_asset,
drive="scsi-hd")
ASSET_PPC64_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/ppc64/vmlinux',
'1d953e81a4379e537fc8e41e05a0a59d9b453eef97aa03d47866c6c45b00bdff')
ASSET_PPC64_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/ppc64/rootfs.ext4.zst',
'f22a9b9e924174a4c199f4c7e5d91a2339fcfe51c6eafd0907dc3e09b64ab728')
def test_ppc64(self):
self.ppc64_common_tuxrun(kernel_asset=self.ASSET_PPC64_KERNEL,
rootfs_asset=self.ASSET_PPC64_ROOTFS,
prefix='tuxrun_ppc64_')
ASSET_PPC64LE_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/ppc64le/vmlinux',
'979eb61b445a010fb13e2b927126991f8ceef9c590fa2be0996c00e293e80cf2')
ASSET_PPC64LE_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/ppc64le/rootfs.ext4.zst',
'b442678c93fb8abe1f7d3bfa20556488de6b475c22c8fed363f42cf81a0a3906')
def test_ppc64le(self):
self.ppc64_common_tuxrun(kernel_asset=self.ASSET_PPC64LE_KERNEL,
rootfs_asset=self.ASSET_PPC64LE_ROOTFS,
prefix='tuxrun_ppc64le_')
if __name__ == '__main__':
TuxRunBaselineTest.main()

35
tests/functional/test_ppc_tuxrun.py Executable file
View File

@ -0,0 +1,35 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunPPC32Test(TuxRunBaselineTest):
ASSET_PPC32_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/ppc32/uImage',
'1a68f74b860fda022fb12e03c5efece8c2b8b590d96cca37a8481a3ae0b3f81f')
ASSET_PPC32_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/ppc32/rootfs.ext4.zst',
'8885b9d999cc24d679542a02e9b6aaf48f718f2050ece6b8347074b6ee41dd09')
def test_ppc32(self):
self.set_machine('ppce500')
self.cpu='e500mc'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_PPC32_KERNEL,
rootfs_asset=self.ASSET_PPC32_ROOTFS,
drive="virtio-blk-pci")
if __name__ == '__main__':
TuxRunBaselineTest.main()

38
tests/functional/test_riscv32_tuxrun.py Executable file
View File

@ -0,0 +1,38 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunRiscV32Test(TuxRunBaselineTest):
ASSET_RISCV32_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/riscv32/Image',
'89599407d7334de629a40e7ad6503c73670359eb5f5ae9d686353a3d6deccbd5')
ASSET_RISCV32_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/riscv32/rootfs.ext4.zst',
'7168d296d0283238ea73cd5a775b3dd608e55e04c7b92b76ecce31bb13108cba')
def test_riscv32(self):
self.set_machine('virt')
self.common_tuxrun(kernel_asset=self.ASSET_RISCV32_KERNEL,
rootfs_asset=self.ASSET_RISCV32_ROOTFS)
def test_riscv32_maxcpu(self):
self.set_machine('virt')
self.cpu='max'
self.common_tuxrun(kernel_asset=self.ASSET_RISCV32_KERNEL,
rootfs_asset=self.ASSET_RISCV32_ROOTFS)
if __name__ == '__main__':
TuxRunBaselineTest.main()

38
tests/functional/test_riscv64_tuxrun.py Executable file
View File

@ -0,0 +1,38 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunRiscV64Test(TuxRunBaselineTest):
ASSET_RISCV64_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/riscv64/Image',
'cd634badc65e52fb63465ec99e309c0de0369f0841b7d9486f9729e119bac25e')
ASSET_RISCV64_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/riscv64/rootfs.ext4.zst',
'b18e3a3bdf27be03da0b285e84cb71bf09eca071c3a087b42884b6982ed679eb')
def test_riscv64(self):
self.set_machine('virt')
self.common_tuxrun(kernel_asset=self.ASSET_RISCV64_KERNEL,
rootfs_asset=self.ASSET_RISCV64_ROOTFS)
def test_riscv64_maxcpu(self):
self.set_machine('virt')
self.cpu='max'
self.common_tuxrun(kernel_asset=self.ASSET_RISCV64_KERNEL,
rootfs_asset=self.ASSET_RISCV64_ROOTFS)
if __name__ == '__main__':
TuxRunBaselineTest.main()

34
tests/functional/test_s390x_tuxrun.py Executable file
View File

@ -0,0 +1,34 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunS390xTest(TuxRunBaselineTest):
ASSET_S390X_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/s390/bzImage',
'0414e98dd1c3dafff8496c9cd9c28a5f8d04553bb5ba37e906a812b48d442ef0')
ASSET_S390X_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/s390/rootfs.ext4.zst',
'88c37c32276677f873a25ab9ec6247895b8e3e6f8259134de2a616080b8ab3fc')
def test_s390(self):
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_S390X_KERNEL,
rootfs_asset=self.ASSET_S390X_ROOTFS,
drive="virtio-blk-ccw",
haltmsg="Requesting system halt")
if __name__ == '__main__':
TuxRunBaselineTest.main()

57
tests/functional/test_sh4_tuxrun.py Executable file
View File

@ -0,0 +1,57 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
import os
import time
from unittest import skipUnless
from qemu_test import Asset, exec_command_and_wait_for_pattern, exec_command
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunSh4Test(TuxRunBaselineTest):
ASSET_SH4_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/sh4/zImage',
'29d9b2aba604a0f53a5dc3b5d0f2b8e35d497de1129f8ee5139eb6fdf0db692f')
ASSET_SH4_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/sh4/rootfs.ext4.zst',
'3592a7a3d5a641e8b9821449e77bc43c9904a56c30d45da0694349cfd86743fd')
# Note: some segfaults caused by unaligned userspace access
@skipUnless(os.getenv('QEMU_TEST_FLAKY_TESTS'), 'Test is unstable')
def test_sh4(self):
self.set_machine('r2d')
self.cpu='sh7785'
self.root='sda'
self.console='ttySC1'
# The test is currently too unstable to do much in userspace
# so we skip common_tuxrun and do a minimal boot and shutdown.
(kernel, disk, dtb) = self.fetch_tuxrun_assets(self.ASSET_SH4_KERNEL,
self.ASSET_SH4_ROOTFS)
# the console comes on the second serial port
self.prepare_run(kernel, disk,
"driver=ide-hd,bus=ide.0,unit=0",
console_index=1)
self.vm.launch()
self.wait_for_console_pattern("Welcome to TuxTest")
time.sleep(0.1)
exec_command(self, 'root')
time.sleep(0.1)
exec_command_and_wait_for_pattern(self, 'halt',
"reboot: System halted")
if __name__ == '__main__':
TuxRunBaselineTest.main()

34
tests/functional/test_sparc64_tuxrun.py Executable file
View File

@ -0,0 +1,34 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunSparc64Test(TuxRunBaselineTest):
ASSET_SPARC64_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/sparc64/vmlinux',
'e34313e4325ff21deaa3d38a502aa09a373ef62b9bd4d7f8f29388b688225c55')
ASSET_SPARC64_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/sparc64/rootfs.ext4.zst',
'ad2f1dc436ab51583543d25d2c210cab478645d47078d30d129a66ab0e281d76')
def test_sparc64(self):
self.root='sda'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_SPARC64_KERNEL,
rootfs_asset=self.ASSET_SPARC64_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

36
tests/functional/test_x86_64_tuxrun.py Executable file
View File

@ -0,0 +1,36 @@
#!/usr/bin/env python3
#
# Functional test that boots known good tuxboot images the same way
# that tuxrun (www.tuxrun.org) does. This tool is used by things like
# the LKFT project to run regression tests on kernels.
#
# Copyright (c) 2023 Linaro Ltd.
#
# Author:
# Alex Bennée <alex.bennee@linaro.org>
#
# SPDX-License-Identifier: GPL-2.0-or-later
from qemu_test import Asset
from qemu_test.tuxruntest import TuxRunBaselineTest
class TuxRunX86Test(TuxRunBaselineTest):
ASSET_X86_64_KERNEL = Asset(
'https://storage.tuxboot.com/20230331/x86_64/bzImage',
'2bc7480a669ee9b6b82500a236aba0c54233debe98cb968268fa230f52f03461')
ASSET_X86_64_ROOTFS = Asset(
'https://storage.tuxboot.com/20230331/x86_64/rootfs.ext4.zst',
'b72ac729769b8f51c6dffb221113c9a063c774dbe1d66af30eb593c4e9999b4b')
def test_x86_64(self):
self.set_machine('q35')
self.cpu="Nehalem"
self.root='sda'
self.wait_for_shutdown=False
self.common_tuxrun(kernel_asset=self.ASSET_X86_64_KERNEL,
rootfs_asset=self.ASSET_X86_64_ROOTFS,
drive="driver=ide-hd,bus=ide.0,unit=0")
if __name__ == '__main__':
TuxRunBaselineTest.main()

1
tests/qtest/meson.build
View File

@ -4,6 +4,7 @@ slow_qtests = {
'bios-tables-test' : 910,
'cdrom-test' : 610,
'device-introspect-test' : 720,
'ide-test' : 120,
'migration-test' : 480,
'npcm7xx_pwm-test': 300,
'npcm7xx_watchdog_timer-test': 120,

6
tests/vm/openbsd
View File

@ -22,8 +22,8 @@ class OpenBSDVM(basevm.BaseVM):
name = "openbsd"
arch = "x86_64"
link = "https://cdn.openbsd.org/pub/OpenBSD/7.5/amd64/install75.iso"
csum = "034435c6e27405d5a7fafb058162943c194eb793dafdc412c08d49bb56b3892a"
link = "https://cdn.openbsd.org/pub/OpenBSD/7.6/amd64/install76.iso"
csum = "60cba8cb391b50bba8fa10fc768bd0529636f5345d82133c93e22c798d8e5269"
size = "20G"
pkgs = [
# tools
@ -32,7 +32,6 @@ class OpenBSDVM(basevm.BaseVM):
"pkgconf",
"bzip2", "xz",
"ninja",
"py3-tomli",
# gnu tools
"bash",
@ -160,6 +159,7 @@ class OpenBSDVM(basevm.BaseVM):
self.print_step("Installation started now, this will take a while")
self.console_wait_send("Location of sets", "done\n")
self.console_wait_send("Time appears wrong. Set to", "\n")
self.console_wait("successfully completed")
self.print_step("Installation finished, rebooting")