* [PATCH 01/17] tests/functional: Add a base class for the TuxRun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 02/17] tests/functional: Convert the Avocado ppc64 tuxrun tests Thomas Huth
` (17 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Add a base class for the TuxRun tests, based on the code from
tests/avocado/tuxrun_baselines.py (the test have to be put into
separate file in the following commits, depending on the target
architecture that gets tested).
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/functional/qemu_test/tuxruntest.py | 158 +++++++++++++++++++++++
1 file changed, 158 insertions(+)
create mode 100644 tests/functional/qemu_test/tuxruntest.py
diff --git a/tests/functional/qemu_test/tuxruntest.py b/tests/functional/qemu_test/tuxruntest.py
new file mode 100644
index 0000000000..904da6f609
--- /dev/null
+++ b/tests/functional/qemu_test/tuxruntest.py
@@ -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)
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 02/17] tests/functional: Convert the Avocado ppc64 tuxrun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
2024-10-11 13:19 ` [PATCH 01/17] tests/functional: Add a base class for the TuxRun tests Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 03/17] tests/functional: Convert the Avocado aarch64 " Thomas Huth
` (16 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-ppc64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 92 ---------------------
tests/functional/test_ppc64_tuxrun.py | 110 ++++++++++++++++++++++++++
2 files changed, 110 insertions(+), 92 deletions(-)
create mode 100755 tests/functional/test_ppc64_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 736e4aa289..56c8bdb2dc 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -182,63 +182,6 @@ def common_tuxrun(self,
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
@@ -436,41 +379,6 @@ def test_ppc32(self):
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
diff --git a/tests/functional/test_ppc64_tuxrun.py b/tests/functional/test_ppc64_tuxrun.py
new file mode 100755
index 0000000000..552b53c97a
--- /dev/null
+++ b/tests/functional/test_ppc64_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 03/17] tests/functional: Convert the Avocado aarch64 tuxrun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
2024-10-11 13:19 ` [PATCH 01/17] tests/functional: Add a base class for the TuxRun tests Thomas Huth
2024-10-11 13:19 ` [PATCH 02/17] tests/functional: Convert the Avocado ppc64 tuxrun tests Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 04/17] tests/functional: Convert the Avocado sparc64 tuxrun test Thomas Huth
` (15 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-aarch64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
MAINTAINERS | 1 +
tests/avocado/tuxrun_baselines.py | 31 ---------------
tests/functional/meson.build | 2 +
tests/functional/test_aarch64_tuxrun.py | 50 +++++++++++++++++++++++++
4 files changed, 53 insertions(+), 31 deletions(-)
create mode 100755 tests/functional/test_aarch64_tuxrun.py
diff --git a/MAINTAINERS b/MAINTAINERS
index d7a11fe601..ab9da679f5 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -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_aarch64_tuxrun.py
Xilinx Zynq
M: Edgar E. Iglesias <edgar.iglesias@gmail.com>
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 56c8bdb2dc..dffa4f6339 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,37 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- def test_arm64(self):
- """
- :avocado: tags=arch:aarch64
- :avocado: tags=cpu:cortex-a57
- :avocado: tags=machine:virt
- :avocado: tags=tuxboot:arm64
- :avocado: tags=console:ttyAMA0
- :avocado: tags=shutdown:nowait
- """
- sums = {"Image" :
- "ce95a7101a5fecebe0fe630deee6bd97b32ba41bc8754090e9ad8961ea8674c7",
- "rootfs.ext4.zst" :
- "bbd5ed4b9c7d3f4ca19ba71a323a843c6b585e880115df3b7765769dbd9dd061"}
- self.common_tuxrun(csums=sums)
-
- def test_arm64be(self):
- """
- :avocado: tags=arch:aarch64
- :avocado: tags=cpu:cortex-a57
- :avocado: tags=endian:big
- :avocado: tags=machine:virt
- :avocado: tags=tuxboot:arm64be
- :avocado: tags=console:ttyAMA0
- :avocado: tags=shutdown:nowait
- """
- sums = { "Image" :
- "e0df4425eb2cd9ea9a283e808037f805641c65d8fcecc8f6407d8f4f339561b4",
- "rootfs.ext4.zst" :
- "e6ffd8813c8a335bc15728f2835f90539c84be7f8f5f691a8b01451b47fb4bd7"}
- self.common_tuxrun(csums=sums)
-
def test_armv5(self):
"""
:avocado: tags=arch:arm
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index c90c02517a..222bfbcc62 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -13,6 +13,7 @@ endif
test_timeouts = {
'aarch64_raspi4' : 120,
'aarch64_sbsaref' : 600,
+ 'aarch64_tuxrun' : 120,
'aarch64_virt' : 360,
'acpi_bits' : 240,
'arm_raspi2' : 120,
@@ -41,6 +42,7 @@ tests_aarch64_system_thorough = [
'aarch64_raspi3',
'aarch64_raspi4',
'aarch64_sbsaref',
+ 'aarch64_tuxrun',
'aarch64_virt',
'multiprocess',
]
diff --git a/tests/functional/test_aarch64_tuxrun.py b/tests/functional/test_aarch64_tuxrun.py
new file mode 100755
index 0000000000..da56aee4ed
--- /dev/null
+++ b/tests/functional/test_aarch64_tuxrun.py
@@ -0,0 +1,50 @@
+#!/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 TuxRunAarch64Test(TuxRunBaselineTest):
+
+ ASSET_ARM64_KERNEL = Asset(
+ 'https://storage.tuxboot.com/20230331/arm64/Image',
+ 'ce95a7101a5fecebe0fe630deee6bd97b32ba41bc8754090e9ad8961ea8674c7')
+ ASSET_ARM64_ROOTFS = Asset(
+ 'https://storage.tuxboot.com/20230331/arm64/rootfs.ext4.zst',
+ 'bbd5ed4b9c7d3f4ca19ba71a323a843c6b585e880115df3b7765769dbd9dd061')
+
+ def test_arm64(self):
+ self.set_machine('virt')
+ self.cpu='cortex-a57'
+ self.console='ttyAMA0'
+ self.wait_for_shutdown=False
+ self.common_tuxrun(kernel_asset=self.ASSET_ARM64_KERNEL,
+ rootfs_asset=self.ASSET_ARM64_ROOTFS)
+
+ ASSET_ARM64BE_KERNEL = Asset(
+ 'https://storage.tuxboot.com/20230331/arm64be/Image',
+ 'e0df4425eb2cd9ea9a283e808037f805641c65d8fcecc8f6407d8f4f339561b4')
+ ASSET_ARM64BE_ROOTFS = Asset(
+ 'https://storage.tuxboot.com/20230331/arm64be/rootfs.ext4.zst',
+ 'e6ffd8813c8a335bc15728f2835f90539c84be7f8f5f691a8b01451b47fb4bd7')
+
+ def test_arm64be(self):
+ self.set_machine('virt')
+ self.cpu='cortex-a57'
+ self.console='ttyAMA0'
+ self.wait_for_shutdown=False
+ self.common_tuxrun(kernel_asset=self.ASSET_ARM64BE_KERNEL,
+ rootfs_asset=self.ASSET_ARM64BE_ROOTFS)
+
+if __name__ == '__main__':
+ TuxRunBaselineTest.main()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 04/17] tests/functional: Convert the Avocado sparc64 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (2 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 03/17] tests/functional: Convert the Avocado aarch64 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 05/17] tests/functional: Convert the Avocado s390x " Thomas Huth
` (14 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test to a new file so that it can be run via
qemu-system-sparc64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
MAINTAINERS | 1 +
tests/avocado/tuxrun_baselines.py | 16 ------------
tests/functional/meson.build | 1 +
tests/functional/test_sparc64_tuxrun.py | 34 +++++++++++++++++++++++++
4 files changed, 36 insertions(+), 16 deletions(-)
create mode 100755 tests/functional/test_sparc64_tuxrun.py
diff --git a/MAINTAINERS b/MAINTAINERS
index ab9da679f5..5493623050 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1656,6 +1656,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>
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index dffa4f6339..dc32735c3f 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -462,22 +462,6 @@ def test_sh4(self):
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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 222bfbcc62..d598f43289 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -142,6 +142,7 @@ tests_sparc_system_thorough = [
tests_sparc64_system_thorough = [
'sparc64_sun4u',
+ 'sparc64_tuxrun',
]
tests_x86_64_system_quick = [
diff --git a/tests/functional/test_sparc64_tuxrun.py b/tests/functional/test_sparc64_tuxrun.py
new file mode 100755
index 0000000000..1c2c005630
--- /dev/null
+++ b/tests/functional/test_sparc64_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 05/17] tests/functional: Convert the Avocado s390x tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (3 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 04/17] tests/functional: Convert the Avocado sparc64 tuxrun test Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 06/17] tests/functional: Convert the Avocado arm tuxrun tests Thomas Huth
` (13 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test to a new file so that it can be run via
qemu-system-s390x in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
MAINTAINERS | 2 +-
tests/avocado/tuxrun_baselines.py | 17 --------------
tests/functional/test_s390x_tuxrun.py | 34 +++++++++++++++++++++++++++
3 files changed, 35 insertions(+), 18 deletions(-)
create mode 100755 tests/functional/test_s390x_tuxrun.py
diff --git a/MAINTAINERS b/MAINTAINERS
index 5493623050..ab9df83c17 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1683,7 +1683,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
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index dc32735c3f..98dce857cf 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -410,23 +410,6 @@ def test_riscv64_maxcpu(self):
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):
diff --git a/tests/functional/test_s390x_tuxrun.py b/tests/functional/test_s390x_tuxrun.py
new file mode 100755
index 0000000000..dcab17c68b
--- /dev/null
+++ b/tests/functional/test_s390x_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 06/17] tests/functional: Convert the Avocado arm tuxrun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (4 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 05/17] tests/functional: Convert the Avocado s390x " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 07/17] tests/functional: Convert the Avocado riscv32 " Thomas Huth
` (12 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-arm in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 56 -----------------------
tests/functional/meson.build | 2 +
tests/functional/test_arm_tuxrun.py | 70 +++++++++++++++++++++++++++++
3 files changed, 72 insertions(+), 56 deletions(-)
create mode 100755 tests/functional/test_arm_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 98dce857cf..59ca9f9706 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,62 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index d598f43289..ae913781ec 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -17,6 +17,7 @@ test_timeouts = {
'aarch64_virt' : 360,
'acpi_bits' : 240,
'arm_raspi2' : 120,
+ 'arm_tuxrun' : 120,
'mips_malta' : 120,
'netdev_ethtool' : 180,
'ppc_40p' : 240,
@@ -56,6 +57,7 @@ tests_arm_system_thorough = [
'arm_integratorcp',
'arm_raspi2',
'arm_vexpress',
+ 'arm_tuxrun',
]
tests_arm_linuxuser_thorough = [
diff --git a/tests/functional/test_arm_tuxrun.py b/tests/functional/test_arm_tuxrun.py
new file mode 100755
index 0000000000..944f0756e1
--- /dev/null
+++ b/tests/functional/test_arm_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 07/17] tests/functional: Convert the Avocado riscv32 tuxrun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (5 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 06/17] tests/functional: Convert the Avocado arm tuxrun tests Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 08/17] tests/functional: Convert the Avocado riscv64 " Thomas Huth
` (11 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-riscv32 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 31 --------------------
tests/functional/meson.build | 4 +++
tests/functional/test_riscv32_tuxrun.py | 38 +++++++++++++++++++++++++
3 files changed, 42 insertions(+), 31 deletions(-)
create mode 100755 tests/functional/test_riscv32_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 59ca9f9706..e84fb9c3b9 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -292,21 +292,6 @@ def test_ppc32(self):
self.common_tuxrun(csums=sums, drive="virtio-blk-pci")
- 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
@@ -322,22 +307,6 @@ def test_riscv64(self):
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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index ae913781ec..1491b4492e 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -129,6 +129,10 @@ tests_rx_system_thorough = [
'rx_gdbsim',
]
+tests_riscv32_system_thorough = [
+ 'riscv32_tuxrun',
+]
+
tests_s390x_system_thorough = [
's390x_ccw_virtio',
's390x_topology',
diff --git a/tests/functional/test_riscv32_tuxrun.py b/tests/functional/test_riscv32_tuxrun.py
new file mode 100755
index 0000000000..49b57cd428
--- /dev/null
+++ b/tests/functional/test_riscv32_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 08/17] tests/functional: Convert the Avocado riscv64 tuxrun tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (6 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 07/17] tests/functional: Convert the Avocado riscv32 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 09/17] tests/functional: Convert the Avocado i386 tuxrun test Thomas Huth
` (10 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-riscv64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 31 --------------------
tests/functional/meson.build | 4 +++
tests/functional/test_riscv64_tuxrun.py | 38 +++++++++++++++++++++++++
3 files changed, 42 insertions(+), 31 deletions(-)
create mode 100755 tests/functional/test_riscv64_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index e84fb9c3b9..dcb6589f2f 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -292,37 +292,6 @@ def test_ppc32(self):
self.common_tuxrun(csums=sums, drive="virtio-blk-pci")
- 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_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)
-
# Note: some segfaults caused by unaligned userspace access
@skipUnless(os.getenv('QEMU_TEST_FLAKY_TESTS'), 'Test is unstable on GitLab')
def test_sh4(self):
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 1491b4492e..94270c798c 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -133,6 +133,10 @@ tests_riscv32_system_thorough = [
'riscv32_tuxrun',
]
+tests_riscv64_system_thorough = [
+ 'riscv64_tuxrun',
+]
+
tests_s390x_system_thorough = [
's390x_ccw_virtio',
's390x_topology',
diff --git a/tests/functional/test_riscv64_tuxrun.py b/tests/functional/test_riscv64_tuxrun.py
new file mode 100755
index 0000000000..13501628f9
--- /dev/null
+++ b/tests/functional/test_riscv64_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 09/17] tests/functional: Convert the Avocado i386 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (7 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 08/17] tests/functional: Convert the Avocado riscv64 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 10/17] tests/functional: Convert the Avocado x86_64 " Thomas Huth
` (9 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-i386 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 16 -------------
tests/functional/meson.build | 4 ++++
tests/functional/test_i386_tuxrun.py | 35 ++++++++++++++++++++++++++++
3 files changed, 39 insertions(+), 16 deletions(-)
create mode 100755 tests/functional/test_i386_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index dcb6589f2f..72b0ad4951 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,22 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 94270c798c..9cdfa1c257 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -68,6 +68,10 @@ tests_avr_system_thorough = [
'avr_mega2560',
]
+tests_i386_system_thorough = [
+ 'i386_tuxrun',
+]
+
tests_loongarch64_system_thorough = [
'loongarch64_virt',
]
diff --git a/tests/functional/test_i386_tuxrun.py b/tests/functional/test_i386_tuxrun.py
new file mode 100755
index 0000000000..c593ffbe8c
--- /dev/null
+++ b/tests/functional/test_i386_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 10/17] tests/functional: Convert the Avocado x86_64 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (8 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 09/17] tests/functional: Convert the Avocado i386 tuxrun test Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 11/17] tests/functional: Convert the Avocado mips " Thomas Huth
` (8 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the tests to a new file so that they can be run via
qemu-system-x86_64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 18 -------------
tests/functional/meson.build | 1 +
tests/functional/test_x86_64_tuxrun.py | 36 ++++++++++++++++++++++++++
3 files changed, 37 insertions(+), 18 deletions(-)
create mode 100755 tests/functional/test_x86_64_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 72b0ad4951..6d00b06713 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -310,21 +310,3 @@ def test_sh4(self):
time.sleep(0.1)
exec_command_and_wait_for_pattern(self, 'halt',
"reboot: System halted")
-
- 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")
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 9cdfa1c257..84012810f7 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -169,6 +169,7 @@ tests_x86_64_system_quick = [
tests_x86_64_system_thorough = [
'acpi_bits',
+ 'x86_64_tuxrun',
'linux_initrd',
'multiprocess',
'netdev_ethtool',
diff --git a/tests/functional/test_x86_64_tuxrun.py b/tests/functional/test_x86_64_tuxrun.py
new file mode 100755
index 0000000000..4f96139871
--- /dev/null
+++ b/tests/functional/test_x86_64_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 11/17] tests/functional: Convert the Avocado mips tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (9 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 10/17] tests/functional: Convert the Avocado x86_64 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 12/17] tests/functional: Convert the Avocado mipsel " Thomas Huth
` (7 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-mips in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 18 --------------
tests/functional/meson.build | 1 +
tests/functional/test_mips_tuxrun.py | 36 ++++++++++++++++++++++++++++
3 files changed, 37 insertions(+), 18 deletions(-)
create mode 100755 tests/functional/test_mips_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 6d00b06713..8593d204b7 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,24 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 84012810f7..4a78c5f8b6 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -92,6 +92,7 @@ tests_microblazeel_system_thorough = [
tests_mips_system_thorough = [
'mips_malta',
+ 'mips_tuxrun',
]
tests_mipsel_system_thorough = [
diff --git a/tests/functional/test_mips_tuxrun.py b/tests/functional/test_mips_tuxrun.py
new file mode 100755
index 0000000000..6fec44c2bf
--- /dev/null
+++ b/tests/functional/test_mips_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 12/17] tests/functional: Convert the Avocado mipsel tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (10 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 11/17] tests/functional: Convert the Avocado mips " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 13/17] tests/functional: Convert the Avocado mips64 " Thomas Huth
` (6 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-mipsel in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 17 ------------
tests/functional/meson.build | 1 +
tests/functional/test_mipsel_tuxrun.py | 36 ++++++++++++++++++++++++++
3 files changed, 37 insertions(+), 17 deletions(-)
create mode 100755 tests/functional/test_mipsel_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 8593d204b7..d45c2ce35e 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,23 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 4a78c5f8b6..813237e412 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -97,6 +97,7 @@ tests_mips_system_thorough = [
tests_mipsel_system_thorough = [
'mipsel_malta',
+ 'mipsel_tuxrun',
]
tests_mips64el_system_thorough = [
diff --git a/tests/functional/test_mipsel_tuxrun.py b/tests/functional/test_mipsel_tuxrun.py
new file mode 100755
index 0000000000..2965bbd913
--- /dev/null
+++ b/tests/functional/test_mipsel_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 13/17] tests/functional: Convert the Avocado mips64 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (11 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 12/17] tests/functional: Convert the Avocado mipsel " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 14/17] tests/functional: Convert the Avocado mips64el " Thomas Huth
` (5 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-mips64 in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 17 -------------
tests/functional/meson.build | 4 +++
tests/functional/test_mips64_tuxrun.py | 35 ++++++++++++++++++++++++++
3 files changed, 39 insertions(+), 17 deletions(-)
create mode 100755 tests/functional/test_mips64_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index d45c2ce35e..e0e6a56067 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,23 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 813237e412..eef48edf52 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -100,6 +100,10 @@ tests_mipsel_system_thorough = [
'mipsel_tuxrun',
]
+tests_mips64_system_thorough = [
+ 'mips64_tuxrun',
+]
+
tests_mips64el_system_thorough = [
'mips64el_fuloong2e',
'mips64el_loongson3v',
diff --git a/tests/functional/test_mips64_tuxrun.py b/tests/functional/test_mips64_tuxrun.py
new file mode 100755
index 0000000000..54af1ae794
--- /dev/null
+++ b/tests/functional/test_mips64_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 14/17] tests/functional: Convert the Avocado mips64el tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (12 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 13/17] tests/functional: Convert the Avocado mips64 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 15/17] tests/functional: Convert the Avocado ppc32 " Thomas Huth
` (4 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-mips64el in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 16 -----------
tests/functional/meson.build | 1 +
tests/functional/test_mips64el_tuxrun.py | 35 ++++++++++++++++++++++++
3 files changed, 36 insertions(+), 16 deletions(-)
create mode 100755 tests/functional/test_mips64el_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index e0e6a56067..18dc7ddaab 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,22 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index eef48edf52..48445edfab 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -108,6 +108,7 @@ tests_mips64el_system_thorough = [
'mips64el_fuloong2e',
'mips64el_loongson3v',
'mips64el_malta',
+ 'mips64el_tuxrun',
]
tests_or1k_system_thorough = [
diff --git a/tests/functional/test_mips64el_tuxrun.py b/tests/functional/test_mips64el_tuxrun.py
new file mode 100755
index 0000000000..819549a27b
--- /dev/null
+++ b/tests/functional/test_mips64el_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 15/17] tests/functional: Convert the Avocado ppc32 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (13 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 14/17] tests/functional: Convert the Avocado mips64el " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 13:19 ` [PATCH 16/17] Revert "hw/sh4/r2d: Realize IDE controller before accessing it" Thomas Huth
` (3 subsequent siblings)
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-ppc in the functional framework.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 16 -------------
tests/functional/meson.build | 1 +
tests/functional/test_ppc_tuxrun.py | 35 +++++++++++++++++++++++++++++
3 files changed, 36 insertions(+), 16 deletions(-)
create mode 100755 tests/functional/test_ppc_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
index 18dc7ddaab..c358095e1f 100644
--- a/tests/avocado/tuxrun_baselines.py
+++ b/tests/avocado/tuxrun_baselines.py
@@ -192,22 +192,6 @@ def common_tuxrun(self,
# --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
#
- 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")
-
# Note: some segfaults caused by unaligned userspace access
@skipUnless(os.getenv('QEMU_TEST_FLAKY_TESTS'), 'Test is unstable on GitLab')
def test_sh4(self):
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index 48445edfab..c17c9b0700 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -126,6 +126,7 @@ tests_ppc_system_thorough = [
'ppc_bamboo',
'ppc_mac',
'ppc_mpc8544ds',
+ 'ppc_tuxrun',
'ppc_virtex_ml507',
]
diff --git a/tests/functional/test_ppc_tuxrun.py b/tests/functional/test_ppc_tuxrun.py
new file mode 100755
index 0000000000..50b76946c4
--- /dev/null
+++ b/tests/functional/test_ppc_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* [PATCH 16/17] Revert "hw/sh4/r2d: Realize IDE controller before accessing it"
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (14 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 15/17] tests/functional: Convert the Avocado ppc32 " Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-11 22:52 ` Philippe Mathieu-Daudé
2024-10-11 13:19 ` [PATCH 17/17] tests/functional: Convert the Avocado sh4 tuxrun test Thomas Huth
` (2 subsequent siblings)
18 siblings, 1 reply; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
This reverts commit 3c5f86a22686ef475a8259c0d8ee714f61c770c9.
Changing the order here caused a regression with the "tuxrun"
kernels (from https://storage.tuxboot.com/20230331/) - ATA commands
fail with a "ata1: lost interrupt (Status 0x58)" message.
Apparently we need to wire the interrupt here first before
realizing the device, so revert the change to the original
behavior.
Reported-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
hw/sh4/r2d.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/hw/sh4/r2d.c b/hw/sh4/r2d.c
index e5ac6751bd..7eecd79fcc 100644
--- a/hw/sh4/r2d.c
+++ b/hw/sh4/r2d.c
@@ -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);
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH 16/17] Revert "hw/sh4/r2d: Realize IDE controller before accessing it"
2024-10-11 13:19 ` [PATCH 16/17] Revert "hw/sh4/r2d: Realize IDE controller before accessing it" Thomas Huth
@ 2024-10-11 22:52 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 23+ messages in thread
From: Philippe Mathieu-Daudé @ 2024-10-11 22:52 UTC (permalink / raw)
To: Thomas Huth, qemu-devel, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm
On 11/10/24 10:19, Thomas Huth wrote:
> This reverts commit 3c5f86a22686ef475a8259c0d8ee714f61c770c9.
>
> Changing the order here caused a regression with the "tuxrun"
> kernels (from https://storage.tuxboot.com/20230331/) - ATA commands
> fail with a "ata1: lost interrupt (Status 0x58)" message.
> Apparently we need to wire the interrupt here first before
> realizing the device, so revert the change to the original
> behavior.
>
> Reported-by: Guenter Roeck <linux@roeck-us.net>
> Signed-off-by: Thomas Huth <thuth@redhat.com>
> ---
> hw/sh4/r2d.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
Acked-by: Philippe Mathieu-Daudé <philmd@linaro.org>
^ permalink raw reply [flat|nested] 23+ messages in thread
* [PATCH 17/17] tests/functional: Convert the Avocado sh4 tuxrun test
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (15 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 16/17] Revert "hw/sh4/r2d: Realize IDE controller before accessing it" Thomas Huth
@ 2024-10-11 13:19 ` Thomas Huth
2024-10-13 15:27 ` [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Alex Bennée
2024-10-21 6:01 ` Thomas Huth
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-11 13:19 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm, Thomas Huth
Move the test into a new file so that it can be run via
qemu-system-sh4 in the functional framework.
Since this was the last test in tests/avocado/tuxrun_baselines.py,
we can now delete that file completely.
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
tests/avocado/tuxrun_baselines.py | 228 ----------------------------
tests/functional/meson.build | 2 +
tests/functional/test_sh4_tuxrun.py | 57 +++++++
3 files changed, 59 insertions(+), 228 deletions(-)
delete mode 100644 tests/avocado/tuxrun_baselines.py
create mode 100755 tests/functional/test_sh4_tuxrun.py
diff --git a/tests/avocado/tuxrun_baselines.py b/tests/avocado/tuxrun_baselines.py
deleted file mode 100644
index c358095e1f..0000000000
--- a/tests/avocado/tuxrun_baselines.py
+++ /dev/null
@@ -1,228 +0,0 @@
-# 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
-import tempfile
-
-from avocado import skip, skipUnless
-from avocado_qemu import QemuSystemTest
-from avocado_qemu import exec_command, exec_command_and_wait_for_pattern
-from avocado_qemu import wait_for_console_pattern
-from avocado.utils import process
-from avocado.utils.path import find_command
-
-class TuxRunBaselineTest(QemuSystemTest):
- """
- :avocado: tags=accel:tcg
- """
-
- 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
- zstd = find_command('zstd', False)
- if zstd is False:
- self.cancel('Could not find "zstd", which is required to '
- 'decompress rootfs')
- self.zstd = zstd
-
- # Process the TuxRun specific tags, 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.get_tag('tuxboot')
-
- # Most Linux's use ttyS0 for their serial port
- self.console = self.get_tag('console', "ttyS0")
-
- # Does the machine shutdown QEMU nicely on "halt"
- self.shutdown = self.get_tag('shutdown')
-
- # The name of the kernel Image file
- self.image = self.get_tag('image', "Image")
-
- self.root = self.get_tag('root', "vda")
-
- # Occasionally we need extra devices to hook things up
- self.extradev = self.get_tag('extradev')
-
- self.qemu_img = super().get_qemu_img()
-
- 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, csums=None, dt=None):
- """
- Fetch the TuxBoot assets. They are stored in a standard way so we
- use the per-test tags to fetch details.
- """
- base_url = f"https://storage.tuxboot.com/20230331/{self.tuxboot}/"
-
- # empty hash if we weren't passed one
- csums = {} if csums is None else csums
- ksum = csums.get(self.image, None)
- isum = csums.get("rootfs.ext4.zst", None)
-
- kernel_image = self.fetch_asset(base_url + self.image,
- asset_hash = ksum,
- algorithm = "sha256")
- disk_image_zst = self.fetch_asset(base_url + "rootfs.ext4.zst",
- asset_hash = isum,
- algorithm = "sha256")
-
- cmd = f"{self.zstd} -d {disk_image_zst} -o {self.workdir}/rootfs.ext4"
- process.run(cmd)
-
- if dt:
- dsum = csums.get(dt, None)
- dtb = self.fetch_asset(base_url + dt,
- asset_hash = dsum,
- algorithm = "sha256")
- else:
- dtb = 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.shutdown == "nowait":
- self.vm.shutdown()
- else:
- self.vm.wait()
-
- def common_tuxrun(self,
- csums=None,
- dt=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(csums, dt)
-
- self.prepare_run(kernel, disk, drive, dtb, console_index)
- self.vm.launch()
- self.run_tuxtest_tests(haltmsg)
-
-
- #
- # The tests themselves. The configuration is derived from how
- # tuxrun invokes qemu (with minor tweaks like using -blockdev
- # consistently). The tuxrun equivalent is something like:
- #
- # tuxrun --device qemu-{ARCH} \
- # --kernel https://storage.tuxboot.com/{TUXBOOT}/{IMAGE}
- #
-
- # 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")
diff --git a/tests/functional/meson.build b/tests/functional/meson.build
index c17c9b0700..51d1037d96 100644
--- a/tests/functional/meson.build
+++ b/tests/functional/meson.build
@@ -156,8 +156,10 @@ tests_s390x_system_thorough = [
tests_sh4_system_thorough = [
'sh4_r2d',
+ 'sh4_tuxrun',
]
+
tests_sparc_system_thorough = [
'sparc_sun4m',
]
diff --git a/tests/functional/test_sh4_tuxrun.py b/tests/functional/test_sh4_tuxrun.py
new file mode 100755
index 0000000000..352cb360ef
--- /dev/null
+++ b/tests/functional/test_sh4_tuxrun.py
@@ -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()
--
2.46.1
^ permalink raw reply related [flat|nested] 23+ messages in thread* Re: [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (16 preceding siblings ...)
2024-10-11 13:19 ` [PATCH 17/17] tests/functional: Convert the Avocado sh4 tuxrun test Thomas Huth
@ 2024-10-13 15:27 ` Alex Bennée
2024-10-14 6:12 ` Thomas Huth
2024-10-21 6:01 ` Thomas Huth
18 siblings, 1 reply; 23+ messages in thread
From: Alex Bennée @ 2024-10-13 15:27 UTC (permalink / raw)
To: Thomas Huth
Cc: qemu-devel, Philippe Mathieu-Daudé, Guenter Roeck,
Yoshinori Sato, Magnus Damm, qemu-arm
Thomas Huth <thuth@redhat.com> writes:
> This patch series converts the tests/avocado/tuxrun_baselines.py
> to the new functional test framework. While converting the sh4 test,
> I noticed that the Avocado test was completely broken, so I included
> a fix (revert) for that problem in this series, too.
How can I run them from meson? I don't see them in list (but make
check-functional works). Shouldn't I be able to do:
./pyvenv/bin/meson test qemu:func-thorough
?
>
> Thomas Huth (17):
> tests/functional: Add a base class for the TuxRun tests
> tests/functional: Convert the Avocado ppc64 tuxrun tests
> tests/functional: Convert the Avocado aarch64 tuxrun tests
> tests/functional: Convert the Avocado sparc64 tuxrun test
> tests/functional: Convert the Avocado s390x tuxrun test
> tests/functional: Convert the Avocado arm tuxrun tests
> tests/functional: Convert the Avocado riscv32 tuxrun tests
> tests/functional: Convert the Avocado riscv64 tuxrun tests
> tests/functional: Convert the Avocado i386 tuxrun test
> tests/functional: Convert the Avocado x86_64 tuxrun test
> tests/functional: Convert the Avocado mips tuxrun test
> tests/functional: Convert the Avocado mipsel tuxrun test
> tests/functional: Convert the Avocado mips64 tuxrun test
> tests/functional: Convert the Avocado mips64el tuxrun test
> tests/functional: Convert the Avocado ppc32 tuxrun test
> Revert "hw/sh4/r2d: Realize IDE controller before accessing it"
> tests/functional: Convert the Avocado sh4 tuxrun test
>
> MAINTAINERS | 4 +-
> hw/sh4/r2d.c | 2 +-
> tests/avocado/tuxrun_baselines.py | 620 -----------------------
> tests/functional/meson.build | 28 +
> tests/functional/qemu_test/tuxruntest.py | 158 ++++++
> tests/functional/test_aarch64_tuxrun.py | 50 ++
> tests/functional/test_arm_tuxrun.py | 70 +++
> tests/functional/test_i386_tuxrun.py | 35 ++
> tests/functional/test_mips64_tuxrun.py | 35 ++
> tests/functional/test_mips64el_tuxrun.py | 35 ++
> tests/functional/test_mips_tuxrun.py | 36 ++
> tests/functional/test_mipsel_tuxrun.py | 36 ++
> tests/functional/test_ppc64_tuxrun.py | 110 ++++
> tests/functional/test_ppc_tuxrun.py | 35 ++
> tests/functional/test_riscv32_tuxrun.py | 38 ++
> tests/functional/test_riscv64_tuxrun.py | 38 ++
> tests/functional/test_s390x_tuxrun.py | 34 ++
> tests/functional/test_sh4_tuxrun.py | 57 +++
> tests/functional/test_sparc64_tuxrun.py | 34 ++
> tests/functional/test_x86_64_tuxrun.py | 36 ++
> 20 files changed, 869 insertions(+), 622 deletions(-)
> delete mode 100644 tests/avocado/tuxrun_baselines.py
> create mode 100644 tests/functional/qemu_test/tuxruntest.py
> create mode 100755 tests/functional/test_aarch64_tuxrun.py
> create mode 100755 tests/functional/test_arm_tuxrun.py
> create mode 100755 tests/functional/test_i386_tuxrun.py
> create mode 100755 tests/functional/test_mips64_tuxrun.py
> create mode 100755 tests/functional/test_mips64el_tuxrun.py
> create mode 100755 tests/functional/test_mips_tuxrun.py
> create mode 100755 tests/functional/test_mipsel_tuxrun.py
> create mode 100755 tests/functional/test_ppc64_tuxrun.py
> create mode 100755 tests/functional/test_ppc_tuxrun.py
> create mode 100755 tests/functional/test_riscv32_tuxrun.py
> create mode 100755 tests/functional/test_riscv64_tuxrun.py
> create mode 100755 tests/functional/test_s390x_tuxrun.py
> create mode 100755 tests/functional/test_sh4_tuxrun.py
> create mode 100755 tests/functional/test_sparc64_tuxrun.py
> create mode 100755 tests/functional/test_x86_64_tuxrun.py
--
Alex Bennée
Virtualisation Tech Lead @ Linaro
^ permalink raw reply [flat|nested] 23+ messages in thread* Re: [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests
2024-10-13 15:27 ` [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Alex Bennée
@ 2024-10-14 6:12 ` Thomas Huth
2024-10-14 10:13 ` Daniel P. Berrangé
0 siblings, 1 reply; 23+ messages in thread
From: Thomas Huth @ 2024-10-14 6:12 UTC (permalink / raw)
To: Alex Bennée
Cc: qemu-devel, Philippe Mathieu-Daudé, Guenter Roeck,
Yoshinori Sato, Magnus Damm, qemu-arm
On 13/10/2024 17.27, Alex Bennée wrote:
> Thomas Huth <thuth@redhat.com> writes:
>
>> This patch series converts the tests/avocado/tuxrun_baselines.py
>> to the new functional test framework. While converting the sh4 test,
>> I noticed that the Avocado test was completely broken, so I included
>> a fix (revert) for that problem in this series, too.
>
> How can I run them from meson? I don't see them in list (but make
> check-functional works). Shouldn't I be able to do:
>
> ./pyvenv/bin/meson test qemu:func-thorough
>
> ?
Did you regenerate the meson files before running this command?
Anyway, the "official" way to run the tests is:
make check-functional
This should take care of
1) Regenerating the meson files if necessary
2) Precaching the assets if necessary
3) Running the tests
Hope that works,
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests
2024-10-14 6:12 ` Thomas Huth
@ 2024-10-14 10:13 ` Daniel P. Berrangé
0 siblings, 0 replies; 23+ messages in thread
From: Daniel P. Berrangé @ 2024-10-14 10:13 UTC (permalink / raw)
To: Thomas Huth
Cc: Alex Bennée, qemu-devel, Philippe Mathieu-Daudé,
Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm
On Mon, Oct 14, 2024 at 08:12:39AM +0200, Thomas Huth wrote:
> On 13/10/2024 17.27, Alex Bennée wrote:
> > Thomas Huth <thuth@redhat.com> writes:
> >
> > > This patch series converts the tests/avocado/tuxrun_baselines.py
> > > to the new functional test framework. While converting the sh4 test,
> > > I noticed that the Avocado test was completely broken, so I included
> > > a fix (revert) for that problem in this series, too.
> >
> > How can I run them from meson? I don't see them in list (but make
> > check-functional works). Shouldn't I be able to do:
> >
> > ./pyvenv/bin/meson test qemu:func-thorough
> >
> > ?
>
> Did you regenerate the meson files before running this command?
>
> Anyway, the "official" way to run the tests is:
>
> make check-functional
>
> This should take care of
> 1) Regenerating the meson files if necessary
> 2) Precaching the assets if necessary
> 3) Running the tests
Or if you just want to run a single test, directly execute the python
file eg ./tests/functional/testname.py
With regards,
Daniel
--
|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org -o- https://fstop138.berrange.com :|
|: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests
2024-10-11 13:19 [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Thomas Huth
` (17 preceding siblings ...)
2024-10-13 15:27 ` [PATCH 00/17] Convert the Avocado tuxrun tests into new functional tests Alex Bennée
@ 2024-10-21 6:01 ` Thomas Huth
18 siblings, 0 replies; 23+ messages in thread
From: Thomas Huth @ 2024-10-21 6:01 UTC (permalink / raw)
To: qemu-devel, Philippe Mathieu-Daudé, Alex Bennée
Cc: Guenter Roeck, Yoshinori Sato, Magnus Damm, qemu-arm
On 11/10/2024 15.19, Thomas Huth wrote:
> This patch series converts the tests/avocado/tuxrun_baselines.py
> to the new functional test framework. While converting the sh4 test,
> I noticed that the Avocado test was completely broken, so I included
> a fix (revert) for that problem in this series, too.
>
> Thomas Huth (17):
> tests/functional: Add a base class for the TuxRun tests
> tests/functional: Convert the Avocado ppc64 tuxrun tests
> tests/functional: Convert the Avocado aarch64 tuxrun tests
> tests/functional: Convert the Avocado sparc64 tuxrun test
> tests/functional: Convert the Avocado s390x tuxrun test
> tests/functional: Convert the Avocado arm tuxrun tests
> tests/functional: Convert the Avocado riscv32 tuxrun tests
> tests/functional: Convert the Avocado riscv64 tuxrun tests
> tests/functional: Convert the Avocado i386 tuxrun test
> tests/functional: Convert the Avocado x86_64 tuxrun test
> tests/functional: Convert the Avocado mips tuxrun test
> tests/functional: Convert the Avocado mipsel tuxrun test
> tests/functional: Convert the Avocado mips64 tuxrun test
> tests/functional: Convert the Avocado mips64el tuxrun test
> tests/functional: Convert the Avocado ppc32 tuxrun test
> Revert "hw/sh4/r2d: Realize IDE controller before accessing it"
> tests/functional: Convert the Avocado sh4 tuxrun test
>
> MAINTAINERS | 4 +-
> hw/sh4/r2d.c | 2 +-
> tests/avocado/tuxrun_baselines.py | 620 -----------------------
> tests/functional/meson.build | 28 +
> tests/functional/qemu_test/tuxruntest.py | 158 ++++++
> tests/functional/test_aarch64_tuxrun.py | 50 ++
> tests/functional/test_arm_tuxrun.py | 70 +++
> tests/functional/test_i386_tuxrun.py | 35 ++
> tests/functional/test_mips64_tuxrun.py | 35 ++
> tests/functional/test_mips64el_tuxrun.py | 35 ++
> tests/functional/test_mips_tuxrun.py | 36 ++
> tests/functional/test_mipsel_tuxrun.py | 36 ++
> tests/functional/test_ppc64_tuxrun.py | 110 ++++
> tests/functional/test_ppc_tuxrun.py | 35 ++
> tests/functional/test_riscv32_tuxrun.py | 38 ++
> tests/functional/test_riscv64_tuxrun.py | 38 ++
> tests/functional/test_s390x_tuxrun.py | 34 ++
> tests/functional/test_sh4_tuxrun.py | 57 +++
> tests/functional/test_sparc64_tuxrun.py | 34 ++
> tests/functional/test_x86_64_tuxrun.py | 36 ++
> 20 files changed, 869 insertions(+), 622 deletions(-)
> delete mode 100644 tests/avocado/tuxrun_baselines.py
> create mode 100644 tests/functional/qemu_test/tuxruntest.py
> create mode 100755 tests/functional/test_aarch64_tuxrun.py
> create mode 100755 tests/functional/test_arm_tuxrun.py
> create mode 100755 tests/functional/test_i386_tuxrun.py
> create mode 100755 tests/functional/test_mips64_tuxrun.py
> create mode 100755 tests/functional/test_mips64el_tuxrun.py
> create mode 100755 tests/functional/test_mips_tuxrun.py
> create mode 100755 tests/functional/test_mipsel_tuxrun.py
> create mode 100755 tests/functional/test_ppc64_tuxrun.py
> create mode 100755 tests/functional/test_ppc_tuxrun.py
> create mode 100755 tests/functional/test_riscv32_tuxrun.py
> create mode 100755 tests/functional/test_riscv64_tuxrun.py
> create mode 100755 tests/functional/test_s390x_tuxrun.py
> create mode 100755 tests/functional/test_sh4_tuxrun.py
> create mode 100755 tests/functional/test_sparc64_tuxrun.py
> create mode 100755 tests/functional/test_x86_64_tuxrun.py
Ok, if there are no objections, I'll include this patch series in my next
pull request, with this small fix squashed into the final patch:
diff --git a/MAINTAINERS b/MAINTAINERS
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4071,7 +4071,8 @@ F: scripts/ci/
F: tests/docker/
F: tests/vm/
F: tests/lcitool/
-F: tests/avocado/tuxrun_baselines.py
+F: tests/functional/qemu_test/tuxruntest.py
+F: tests/functional/test_*_tuxrun.py
F: scripts/archive-source.sh
F: docs/devel/testing.rst
W: https://gitlab.com/qemu-project/qemu/pipelines
Thomas
^ permalink raw reply [flat|nested] 23+ messages in thread