[PULL 00/23] s390x queue

[PULL 00/23] s390x queue

[Eric Farman]

The following changes since commit 3876503faff51ce3a132dbbd0ab42c10f2269319:

  Merge tag 'target-misc-20260924' of https://github.com/philmd/qemu into staging (2026-09-24 13:30:19 -0700)

are available in the Git repository at:

  https://gitlab.com/efarman/qemu.git tags/s390x-20260930

for you to fetch changes up to cf8299050666ee84ee400a3a0195be7598850e93:

  pc-bios/s390-ccw.img: update s390x bios (2026-09-30 09:09:14 -0400)

----------------------------------------------------------------
New s390x features for 11.2
 - enable boot via virtio-net-pci
 - PCI and SCLP fixes
 - hardening fixes throughout
 - regenerate s390-ccw.img


Eric Farman (10):
  virtio-ccw: Limit ISC to MAX_ISC
  virtio-ccw: Do not overwrite existing indicators
  virtio-ccw: Fix rc check in read configuration path
  vfio/ap: Clear error object pointer after non-fatal errors
  vfio/ccw: Clear error object pointer after non-fatal errors
  hw/intc/s390x: Fix payload to KVM_HAS_DEVICE_ATTR ioctl
  hw/intc/s390x: Fix check after g_try_realloc
  s390x/css: Use datastream pointer for checking no-data CCWs
  s390x/sclp: Reject short headers in PV case
  pc-bios/s390-ccw.img: update s390x bios

Janosch Frank (1):
  s390x: Expose pv attribute in QOM

Matthew Rosato (3):
  s390x/pci: Fix frame stepping in rpcit_service_call()
  s390x/pci: Use qemu_log_mask() for guest-triggered errors in
    reg_ioat()
  s390x/pci: Reject apertures beyond IOAT capacity in translation mode

Maximilian Immanuel Brandtner (1):
  s390x/sclpconsole: fix indentation for console_reset

Zhuoying Cai (8):
  pc-bios/s390-ccw: Move CCW net setup to virtio-ccw
  pc-bios/s390-ccw: Add dynamic net header size handling
  pc-bios/s390-ccw: Introduce virtio_tswap helpers
  pc-bios/s390-ccw: Add support for virtio-net-pci IPL
  hw/virtio: Add "loadparm" property to virtio net PCI devices booting
    on s390x
  tests/qtest: Check s390x boot device support in pxe-test.c
  tests/qtest: Add s390x virtio net PCI test to pxe-test.c
  tests/functional/s390x: Add tests for virtio net PCI in
    test_pxelinux.py

 docs/system/s390x/protvirt.rst          |  11 +++
 hw/char/sclpconsole.c                   |  18 ++---
 hw/intc/s390_flic_kvm.c                 |   8 +-
 hw/s390x/css.c                          |  28 +++++--
 hw/s390x/s390-pci-inst.c                |  25 +++++-
 hw/s390x/s390-virtio-ccw.c              |  13 ++++
 hw/s390x/sclp.c                         |   6 ++
 hw/s390x/virtio-ccw.c                   |  29 ++++++-
 hw/vfio/ap.c                            |   4 +
 hw/vfio/ccw.c                           |   2 +
 hw/virtio/virtio-net-pci.c              |   1 +
 include/hw/s390x/s390-pci-bus.h         |   1 +
 pc-bios/s390-ccw.img                    | Bin 112408 -> 112408 bytes
 pc-bios/s390-ccw/main.c                 |   2 +
 pc-bios/s390-ccw/netmain.c              |  73 +++---------------
 pc-bios/s390-ccw/virtio-ccw.c           |  62 +++++++++++++++
 pc-bios/s390-ccw/virtio-ccw.h           |   1 +
 pc-bios/s390-ccw/virtio-net.c           |  66 ++++++++++++----
 pc-bios/s390-ccw/virtio-pci.c           |  20 +++++
 pc-bios/s390-ccw/virtio.c               |  27 +++++--
 pc-bios/s390-ccw/virtio.h               |   4 +
 tests/functional/s390x/test_pxelinux.py |  71 +++++++++++++++---
 tests/qtest/meson.build                 |   1 +
 tests/qtest/pxe-test.c                  |  96 +++++++++++++++++++++++-
 24 files changed, 448 insertions(+), 121 deletions(-)

-- 
2.55.0

[PULL 01/23] virtio-ccw: Limit ISC to MAX_ISC

[Eric Farman]

The interrupt subclass is often defined as a uint8, though in practice
it will be within the range of just 0-7. Ensure that a guest-supplied
subclass does not extend beyond its expected range, especially when
used as an array index.

Cc: qemu-stable@nongnu.org
Fixes: 25a08b8ded ("s390x/css: update css_adapter_interrupt")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-2-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/css.c        | 7 ++++++-
 hw/s390x/virtio-ccw.c | 6 ++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/hw/s390x/css.c b/hw/s390x/css.c
index 76dbca3bb9..9da9128d88 100644
--- a/hw/s390x/css.c
+++ b/hw/s390x/css.c
@@ -654,8 +654,13 @@ void css_adapter_interrupt(CssIoAdapterType type, uint8_t isc)
     S390FLICState *fs = s390_get_flic();
     S390FLICStateClass *fsc = s390_get_flic_class(fs);
     uint32_t io_int_word = (isc << 27) | IO_INT_WORD_AI;
-    IoAdapter *adapter = channel_subsys.io_adapters[type][isc];
+    IoAdapter *adapter;
+
+    if (type >= CSS_IO_ADAPTER_TYPE_NUMS || isc > MAX_ISC) {
+        return;
+    }
 
+    adapter = channel_subsys.io_adapters[type][isc];
     if (!adapter) {
         return;
     }
diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
index 30fb2c0681..eb6378ea4c 100644
--- a/hw/s390x/virtio-ccw.c
+++ b/hw/s390x/virtio-ccw.c
@@ -46,6 +46,10 @@ static int virtio_ccw_dev_post_load(void *opaque, int version_id)
     CcwDevice *ccw_dev = CCW_DEVICE(dev);
     CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
 
+    if (dev->thinint_isc > MAX_ISC) {
+        return -EINVAL;
+    }
+
     ccw_dev->sch->driver_data = dev;
     if (ccw_dev->sch->thinint_active) {
         dev->routes.adapter.adapter_id = css_get_adapter_id(
@@ -659,6 +663,8 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
         } else {
             if (ccw_dstream_read(&sch->cds, thinint)) {
                 ret = -EFAULT;
+            } else if (thinint.isc > MAX_ISC) {
+                ret = -ENOSYS;
             } else {
                 thinint.ind_bit = be64_to_cpu(thinint.ind_bit);
                 thinint.summary_indicator =
-- 
2.55.0

[PULL 02/23] virtio-ccw: Do not overwrite existing indicators

[Eric Farman]

The various indicators pointers allow them to be overwritten,
but leak any existing structs that might be there. If indicators
exist, ensure that they are released before setting the new ones.

Both the regular and adapter interrupt paths check that they
aren't being asked to enable interrupts when the other one is
enabled, so just do this release once all the potential checks
are completed.

Cc: qemu-stable@nongnu.org
Fixes: 7bca3892cb ("s390x/virtio-ccw: reference-counted indicators")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-3-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/virtio-ccw.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
index eb6378ea4c..f46f936150 100644
--- a/hw/s390x/virtio-ccw.c
+++ b/hw/s390x/virtio-ccw.c
@@ -582,6 +582,11 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
             if (ret) {
                 break;
             }
+            if (dev->indicators) {
+                /* Need to remove existing indicators first */
+                release_indicator(&dev->routes.adapter, dev->indicators);
+                dev->indicators = NULL;
+            }
             indicators = be64_to_cpu(indicators);
             dev->indicators = get_indicator(indicators, sizeof(uint64_t));
             sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
@@ -606,6 +611,11 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
             if (ret) {
                 break;
             }
+            if (dev->indicators2) {
+                /* Need to remove existing indicators first */
+                release_indicator(&dev->routes.adapter, dev->indicators2);
+                dev->indicators2 = NULL;
+            }
             indicators = be64_to_cpu(indicators);
             dev->indicators2 = get_indicator(indicators, sizeof(uint64_t));
             sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
@@ -666,6 +676,17 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
             } else if (thinint.isc > MAX_ISC) {
                 ret = -ENOSYS;
             } else {
+                if (dev->indicators) {
+                    /* Need to remove existing indicators first */
+                    release_indicator(&dev->routes.adapter, dev->indicators);
+                    dev->indicators = NULL;
+                }
+                if (dev->summary_indicator) {
+                    /* Need to remove existing indicators first */
+                    release_indicator(&dev->routes.adapter,
+                                      dev->summary_indicator);
+                    dev->summary_indicator = NULL;
+                }
                 thinint.ind_bit = be64_to_cpu(thinint.ind_bit);
                 thinint.summary_indicator =
                     be64_to_cpu(thinint.summary_indicator);
-- 
2.55.0

[PULL 03/23] virtio-ccw: Fix rc check in read configuration path

[Eric Farman]

Both the read and write config paths use wrappers around cds->op_handler,
depending on the direction the I/O is flowing. But they expect opposite
values in the returned variable to indicate success.

Fix this by unifying those checks, where CCW_CMD_READ_CONF needs to
see !ret as success. The end result is some erroneous data in the
SCSW response data, but the overall success/failure is correct.

Cc: qemu-stable@nongnu.org
Fixes: d895d25ae2 ("s390x: css: report errors from ccw_dstream_read/write")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-4-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/virtio-ccw.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
index f46f936150..11441e56c1 100644
--- a/hw/s390x/virtio-ccw.c
+++ b/hw/s390x/virtio-ccw.c
@@ -475,7 +475,7 @@ static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
         } else {
             virtio_bus_get_vdev_config(&dev->bus, vdev->config);
             ret = ccw_dstream_write_buf(&sch->cds, vdev->config, len);
-            if (ret) {
+            if (!ret) {
                 sch->curr_status.scsw.count = ccw.count - len;
             }
         }
-- 
2.55.0

[PULL 04/23] vfio/ap: Clear error object pointer after non-fatal errors

[Eric Farman]

Registering a new IRQ notifier will allocate an error object if needed,
and warn_report_err() will release that memory once it's finished.
The pointer remains, however, so subsequent errors after the non-fatal
errors in vfio_ap_realize() would cause an assertion failure for a
non-NULL pointer.

Fix this by clearing the pointer once the warning has been reported,
to reset the state of the error objects.

Cc: Anthony Krowiak <akrowiak@linux.ibm.com>
Cc: qemu-stable@nongnu.org
Fixes: 1360b2ad1f ("s390x/ap: Wire up the device request notifier interface")
Fixes: 0fb8a62fe4 ("hw/vfio/ap: notification handler for AP config changed event")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Anthony Krowiak <akrowiak@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-5-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/vfio/ap.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/hw/vfio/ap.c b/hw/vfio/ap.c
index 6e2a1223ea..2926e04ad4 100644
--- a/hw/vfio/ap.c
+++ b/hw/vfio/ap.c
@@ -247,8 +247,10 @@ static void vfio_ap_realize(DeviceState *dev, Error **errp)
         /*
          * Report this error, but do not make it a failing condition.
          * Lack of this IRQ in the host does not prevent normal operation.
+         * Clear the pointer, since the warning will release it.
          */
         warn_report_err(err);
+        err = NULL;
     }
 
     if (!vfio_ap_register_irq_notifier(vapdev, VFIO_AP_CFG_CHG_IRQ_INDEX, &err))
@@ -256,8 +258,10 @@ static void vfio_ap_realize(DeviceState *dev, Error **errp)
         /*
          * Report this error, but do not make it a failing condition.
          * Lack of this IRQ in the host does not prevent normal operation.
+         * Clear the pointer, since the warning will release it.
          */
         warn_report_err(err);
+        err = NULL;
     }
 
     return;
-- 
2.55.0

[PULL 05/23] vfio/ccw: Clear error object pointer after non-fatal errors

[Eric Farman]

Just like in vfio/ap, there is a non-fatal message that could be
generated, with a stale pointer in the error object variable.

Unlike vfio/ap, there is no secondary message that could attempt
to use it. Clear it in the same way, in case that ever changes.

Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-6-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/vfio/ccw.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/hw/vfio/ccw.c b/hw/vfio/ccw.c
index c3dc7c1962..8e29a3ae61 100644
--- a/hw/vfio/ccw.c
+++ b/hw/vfio/ccw.c
@@ -604,8 +604,10 @@ static void vfio_ccw_realize(DeviceState *dev, Error **errp)
         /*
          * Report this error, but do not make it a failing condition.
          * Lack of this IRQ in the host does not prevent normal operation.
+         * Clear the pointer, since the warning will release it.
          */
         warn_report_err(err);
+        err = NULL;
     }
 
     return;
-- 
2.55.0

[PULL 06/23] hw/intc/s390x: Fix payload to KVM_HAS_DEVICE_ATTR ioctl

[Eric Farman]

The ioctl to determine whether KVM_DEV_FLIC_CLEAR_IO_IRQ is present
receives the contents of the attribute struct as its payload,
rather than a pointer to the payload itself as is convention.

This may result in erroneous errors from the ioctl, which would
result in clear_io_supported being false when it otherwise could
be used (which is helpful in device recovery).

Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-7-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/intc/s390_flic_kvm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/intc/s390_flic_kvm.c b/hw/intc/s390_flic_kvm.c
index f833a3996a..5e6d422fba 100644
--- a/hw/intc/s390_flic_kvm.c
+++ b/hw/intc/s390_flic_kvm.c
@@ -633,7 +633,7 @@ static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
     /* Check clear_io_irq support */
     test_attr.group = KVM_DEV_FLIC_CLEAR_IO_IRQ;
     flic_state->clear_io_supported = !ioctl(flic_state->fd,
-                                            KVM_HAS_DEVICE_ATTR, test_attr);
+                                            KVM_HAS_DEVICE_ATTR, &test_attr);
 }
 
 static void kvm_s390_flic_reset(DeviceState *dev)
-- 
2.55.0

[PULL 07/23] hw/intc/s390x: Fix check after g_try_realloc

[Eric Farman]

The loop to store pending IRQs uses g_try_realloc() to expand the
buffer being used, but the returned address is stored in a
pointer-to-pointer, thus the check is supposed to be examining
the contents of the pointer, and not the pointer itself.

Define a temporary variable to catch and test the returned pointer.
If it's NULL, return to the caller to perform the free on the
unmodified buffer. If it's not NULL, store it in the caller's
pointer and restart the loop against the new struct.

Cc: qemu-stable@nongnu.org
Fixes: 3a553fc658 ("s390x/kvm: implement floating-interrupt controller device")
Reviewed-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-8-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/intc/s390_flic_kvm.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/hw/intc/s390_flic_kvm.c b/hw/intc/s390_flic_kvm.c
index 5e6d422fba..63c6ce81d9 100644
--- a/hw/intc/s390_flic_kvm.c
+++ b/hw/intc/s390_flic_kvm.c
@@ -254,6 +254,7 @@ static int __get_all_irqs(KVMS390FLICState *flic,
                           void **buf, int len)
 {
     int r;
+    void *new_buf = NULL;
 
     do {
         /* returns -ENOMEM if buffer is too small and number
@@ -263,10 +264,11 @@ static int __get_all_irqs(KVMS390FLICState *flic,
             break;
         }
         len *= 2;
-        *buf = g_try_realloc(*buf, len);
-        if (!buf) {
+        new_buf = g_try_realloc(*buf, len);
+        if (!new_buf) {
             return -ENOMEM;
         }
+        *buf = new_buf;
     } while (r == -ENOMEM && len <= KVM_S390_FLIC_MAX_BUFFER);
 
     return r;
-- 
2.55.0

[PULL 08/23] s390x/css: Use datastream pointer for checking no-data CCWs

[Eric Farman]

The channel subsystem will reject channel programs that incorporate
256 CCWs without a data transfer, but the existing check to account
for this only does so for CCWs with a data address of zero. Other
valid CCWs that wouldn't transfer data are not accounted for.

Rather than re-inventing the wheel, use the output of the datastream
at the end of the entire CCW parsing tree to indicate whether data
was moved or not.

Cc: qemu-stable@nongnu.org
Fixes: e8601dd5d0 ("s390x/css: catch ccw sequence errors")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-9-farman@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/css.c | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/hw/s390x/css.c b/hw/s390x/css.c
index 9da9128d88..65341c68c3 100644
--- a/hw/s390x/css.c
+++ b/hw/s390x/css.c
@@ -1016,13 +1016,6 @@ static int css_interpret_ccw(SubchDev *sch, hwaddr ccw_addr,
 
     check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC));
 
-    if (!ccw.cda) {
-        if (sch->ccw_no_data_cnt == 255) {
-            return -EINVAL;
-        }
-        sch->ccw_no_data_cnt++;
-    }
-
     /* Look at the command. */
     ccw_dstream_init(&sch->cds, &ccw, &(sch->orb));
     switch (ccw.cmd_code) {
@@ -1103,6 +1096,20 @@ static int css_interpret_ccw(SubchDev *sch, hwaddr ccw_addr,
     }
     sch->last_cmd = ccw;
     sch->last_cmd_valid = true;
+
+    /*
+     * A CCW that transfers no data is allowed, but ensure an upper limit
+     * is established to prevent long-running channel programs that don't
+     * move actual data.
+     */
+    if (ret == 0 && sch->cds.at_byte == 0) {
+        if (sch->ccw_no_data_cnt == 255) {
+            ret = -EINVAL;
+        } else {
+            sch->ccw_no_data_cnt++;
+        }
+    }
+
     if (ret == 0) {
         if (ccw.flags & CCW_FLAG_CC) {
             sch->channel_prog += 8;
-- 
2.55.0

[PULL 09/23] s390x/sclp: Reject short headers in PV case

[Eric Farman]

An invalid length in an SCCB header correctly generates a specification
exception for the regular (non-PV) codepath that processes an SCLP
instruction intercept. The PV case doesn't, because the UV enforces
a valid length before getting to this point. The length is used to
allocate storage later down the line, so doublecheck the length here
in the (unlikely) case it is too short.

Cc: Janosch Frank <frankja@linux.ibm.com>
Cc: qemu-stable@nongnu.org
Fixes: c1db53a591 ("s390/sclp: read sccb from mem based on provided length")
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Acked-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260922201526.2383047-10-farman@linux.ibm.com
[farman@linux.ibm.com: Updated commit/comment text, per Janosch]
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/sclp.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/hw/s390x/sclp.c b/hw/s390x/sclp.c
index d8b655efcc..ebd5e859c5 100644
--- a/hw/s390x/sclp.c
+++ b/hw/s390x/sclp.c
@@ -277,6 +277,11 @@ int sclp_service_call_protected(S390CPU *cpu, uint64_t sccb, uint32_t code)
 
     s390_cpu_pv_mem_read(env_archcpu(env), 0, &header, sizeof(SCCBHeader));
 
+    /* We should never end up here due to UV checks, but lets be sure */
+    if (be16_to_cpu(header.length) < sizeof(SCCBHeader)) {
+        goto out_no_write;
+    }
+
     work_sccb = g_malloc0(be16_to_cpu(header.length));
     s390_cpu_pv_mem_read(env_archcpu(env), 0, work_sccb,
                          be16_to_cpu(header.length));
@@ -290,6 +295,7 @@ int sclp_service_call_protected(S390CPU *cpu, uint64_t sccb, uint32_t code)
 out_write:
     s390_cpu_pv_mem_write(env_archcpu(env), 0, work_sccb,
                           be16_to_cpu(header.length));
+out_no_write:
     sclp_c->service_interrupt(sclp, SCLP_PV_DUMMY_ADDR);
     return 0;
 }
-- 
2.55.0

[PULL 10/23] s390x: Expose pv attribute in QOM

[Eric Farman]

From: Janosch Frank <frankja@linux.ibm.com>

People doing VM management requested a way to query if a VM is in PV
or not. So this patch exposes the runtime PV attribute which is true
once the VM successfully made the switch into PV mode (according to
KVM) and did not yet reboot to drop out of it.

This of course does never replace attestation, it's merely QEMU's view
of the situation.

Signed-off-by: Janosch Frank <frankja@linux.ibm.com>
CC: Hendrik Brueckner <brueckner@linux.ibm.com>
Reviewed-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Reviewed-by: Eric Farman <farman@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Hendrik Brueckner <brueckner@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924142846.157848-1-frankja@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 docs/system/s390x/protvirt.rst | 11 +++++++++++
 hw/s390x/s390-virtio-ccw.c     | 13 +++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/docs/system/s390x/protvirt.rst b/docs/system/s390x/protvirt.rst
index aee63ed7ec..7e6c6e10f4 100644
--- a/docs/system/s390x/protvirt.rst
+++ b/docs/system/s390x/protvirt.rst
@@ -65,3 +65,14 @@ metadata. In case this boot method is used, the command line
 options -initrd and -cmdline are ineffective. The preparation of a PVM
 image is done via the ``genprotimg`` tool from the s390-tools
 collection.
+
+
+PV property
+-----------
+
+The s390x-ccw machine exposes the read-only runtime "pv"
+property. This property is true if a guest successfully made the
+transition into PV mode as reported by KVM and hasn't yet exited PV
+mode via a reboot. This does not replace PV attestation which is the
+only authoritative way to get a definitive answer if a guest is truly
+protected.
diff --git a/hw/s390x/s390-virtio-ccw.c b/hw/s390x/s390-virtio-ccw.c
index 7fb78d8fa1..9e2db872fb 100644
--- a/hw/s390x/s390-virtio-ccw.c
+++ b/hw/s390x/s390-virtio-ccw.c
@@ -838,6 +838,13 @@ static inline void machine_set_secure_boot(Object *obj, bool value,
     ms->secure_boot = value;
 }
 
+static inline bool machine_get_pv(Object *obj, Error **errp)
+{
+    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+
+    return ms->pv;
+}
+
  /*
   * S390x-specific global compatibility properties.
   *
@@ -919,6 +926,12 @@ static void ccw_machine_class_init(ObjectClass *oc, const void *data)
                                    machine_set_secure_boot);
     object_class_property_set_description(oc, "secure-boot",
             "enable/disable secure boot");
+
+    object_class_property_add_bool(oc, "pv",
+                                   machine_get_pv,
+                                   NULL);
+    object_class_property_set_description(oc, "pv",
+            "true while the guest runs in protected virtualization mode (read-only)");
 }
 
 static inline void s390_machine_initfn(Object *obj)
-- 
2.55.0

[PULL 11/23] pc-bios/s390-ccw: Move CCW net setup to virtio-ccw

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Move CCW-specific virtio_setup() and find_net_dev() to virtio-ccw.c
to decouple the generic net boot logic from the CCW transport.
Also update the error message on failure to specify "ccw net device".

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Reviewed-by: Jason J. Herne <jjherne@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-2-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 pc-bios/s390-ccw/netmain.c    | 67 ++---------------------------------
 pc-bios/s390-ccw/virtio-ccw.c | 62 ++++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/virtio-ccw.h |  1 +
 3 files changed, 66 insertions(+), 64 deletions(-)

diff --git a/pc-bios/s390-ccw/netmain.c b/pc-bios/s390-ccw/netmain.c
index ccd1c30013..bcb62bf6ca 100644
--- a/pc-bios/s390-ccw/netmain.c
+++ b/pc-bios/s390-ccw/netmain.c
@@ -35,6 +35,7 @@
 #include "s390-ccw.h"
 #include "cio.h"
 #include "virtio.h"
+#include "virtio-ccw.h"
 #include "s390-time.h"
 
 #define DEFAULT_BOOT_RETRIES 10
@@ -489,68 +490,6 @@ static int net_try_direct_tftp_load(filename_ip_t *fn_ip)
     return rc;
 }
 
-static bool find_net_dev(Schib *schib, int dev_no)
-{
-    int i, r;
-
-    for (i = 0; i < 0x10000; i++) {
-        net_schid.sch_no = i;
-        r = stsch_err(net_schid, schib);
-        if (r == 3 || r == -EIO) {
-            break;
-        }
-        if (!schib->pmcw.dnv) {
-            continue;
-        }
-        enable_subchannel(net_schid);
-        if (!virtio_is_supported(virtio_get_device())) {
-            continue;
-        }
-        if (virtio_get_device_type() != VIRTIO_ID_NET) {
-            continue;
-        }
-        if (dev_no < 0 || schib->pmcw.dev == dev_no) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static bool virtio_setup(void)
-{
-    Schib schib;
-    int ssid;
-    bool found = false;
-    uint16_t dev_no;
-
-    /*
-     * We unconditionally enable mss support. In every sane configuration,
-     * this will succeed; and even if it doesn't, stsch_err() can deal
-     * with the consequences.
-     */
-    enable_mss_facility();
-
-    if (have_iplb || store_iplb(iplb)) {
-        IPL_assert(iplb->pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected");
-        dev_no = iplb->ccw.devno;
-        debug_print_int("device no. ", dev_no);
-        net_schid.ssid = iplb->ccw.ssid & 0x3;
-        debug_print_int("ssid ", net_schid.ssid);
-        found = find_net_dev(&schib, dev_no);
-    } else {
-        for (ssid = 0; ssid < 0x3; ssid++) {
-            net_schid.ssid = ssid;
-            found = find_net_dev(&schib, -1);
-            if (found) {
-                break;
-            }
-        }
-    }
-
-    return found;
-}
-
 int netmain(void)
 {
     filename_ip_t fn_ip;
@@ -559,8 +498,8 @@ int netmain(void)
     sclp_setup();
     puts("Network boot starting...");
 
-    if (!virtio_setup()) {
-        puts("No virtio net device found.");
+    if (!virtio_ccw_net_setup()) {
+        puts("No valid virtio ccw net device found.");
         return -1;
     }
 
diff --git a/pc-bios/s390-ccw/virtio-ccw.c b/pc-bios/s390-ccw/virtio-ccw.c
index ea5dbc2857..3c2c44529c 100644
--- a/pc-bios/s390-ccw/virtio-ccw.c
+++ b/pc-bios/s390-ccw/virtio-ccw.c
@@ -220,3 +220,65 @@ int virtio_ccw_setup(VDev *vdev)
 
     return 0;
 }
+
+static bool find_ccw_net_dev(Schib *schib, int dev_no)
+{
+    int i, r;
+
+    for (i = 0; i < 0x10000; i++) {
+        net_schid.sch_no = i;
+        r = stsch_err(net_schid, schib);
+        if (r == 3 || r == -EIO) {
+            break;
+        }
+        if (!schib->pmcw.dnv) {
+            continue;
+        }
+        enable_subchannel(net_schid);
+        if (!virtio_is_supported(virtio_get_device())) {
+            continue;
+        }
+        if (virtio_get_device_type() != VIRTIO_ID_NET) {
+            continue;
+        }
+        if (dev_no < 0 || schib->pmcw.dev == dev_no) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool virtio_ccw_net_setup(void)
+{
+    Schib schib;
+    int ssid;
+    bool found = false;
+    uint16_t dev_no;
+
+    /*
+     * We unconditionally enable mss support. In every sane configuration,
+     * this will succeed; and even if it doesn't, stsch_err() can deal
+     * with the consequences.
+     */
+    enable_mss_facility();
+
+    if (have_iplb || store_iplb(iplb)) {
+        IPL_assert(iplb->pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected");
+        dev_no = iplb->ccw.devno;
+        debug_print_int("device no. ", dev_no);
+        net_schid.ssid = iplb->ccw.ssid & 0x3;
+        debug_print_int("ssid ", net_schid.ssid);
+        found = find_ccw_net_dev(&schib, dev_no);
+    } else {
+        for (ssid = 0; ssid < 0x3; ssid++) {
+            net_schid.ssid = ssid;
+            found = find_ccw_net_dev(&schib, -1);
+            if (found) {
+                break;
+            }
+        }
+    }
+
+    return found;
+}
diff --git a/pc-bios/s390-ccw/virtio-ccw.h b/pc-bios/s390-ccw/virtio-ccw.h
index 43d21906e5..7768c152d0 100644
--- a/pc-bios/s390-ccw/virtio-ccw.h
+++ b/pc-bios/s390-ccw/virtio-ccw.h
@@ -19,5 +19,6 @@ bool virtio_ccw_is_supported(VDev *vdev);
 long virtio_ccw_notify(SubChannelId schid, int vq_idx, long cookie);
 int virtio_ccw_setup(VDev *vdev);
 int virtio_ccw_reset(VDev *vdev);
+bool virtio_ccw_net_setup(void);
 
 #endif
-- 
2.55.0

[PULL 12/23] pc-bios/s390-ccw: Add dynamic net header size handling

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

The virtio-net device used a fixed header size that did not account for
the num_buffers field used in VirtIO 1.0.

Use dynamic header sizing: 10 bytes for legacy mode and 12 bytes for
VirtIO 1.0. This ensures correct packet handling across different
VirtIO configurations.

The VirtioNetHdr and VirtioNetHdrMrgRxbuf structures replicate the
same field layout as struct virtio_net_hdr and struct
virtio_net_hdr_mrg_rxbuf defined in include/uapi/linux/virtio_net.h.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Acked-by: Christian Borntraeger <borntraeger@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-3-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 pc-bios/s390-ccw/virtio-net.c | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/pc-bios/s390-ccw/virtio-net.c b/pc-bios/s390-ccw/virtio-net.c
index f58f7ffc55..7bb3f8f551 100644
--- a/pc-bios/s390-ccw/virtio-net.c
+++ b/pc-bios/s390-ccw/virtio-net.c
@@ -20,6 +20,7 @@
 #include "s390-ccw.h"
 #include "virtio.h"
 #include "virtio-ccw.h"
+#include "virtio-pci.h"
 #include "s390-time.h"
 #include "helper.h"
 
@@ -39,11 +40,21 @@ struct VirtioNetHdr {
     uint16_t gso_size;
     uint16_t csum_start;
     uint16_t csum_offset;
-    /*uint16_t num_buffers;*/ /* Only with VIRTIO_NET_F_MRG_RXBUF or VIRTIO1 */
 };
 typedef struct VirtioNetHdr VirtioNetHdr;
 
+struct VirtioNetHdrMrgRxbuf {
+    struct VirtioNetHdr hdr;
+    uint16_t num_buffers; /* Only with VIRTIO_NET_F_MRG_RXBUF or VIRTIO1 */
+};
+typedef struct VirtioNetHdrMrgRxbuf VirtioNetHdrMrgRxbuf;
+
+/* Header sizes for different modes */
+#define VIRTIO_NET_HDR_SIZE_LEGACY  sizeof(VirtioNetHdr)
+#define VIRTIO_NET_HDR_SIZE_V1      sizeof(VirtioNetHdrMrgRxbuf)
+
 static uint16_t rx_last_idx;  /* Last index in receive queue "used" ring */
+static int virtio_net_hdr_size;
 
 int virtio_net_init(void *mac_addr)
 {
@@ -62,12 +73,16 @@ int virtio_net_init(void *mac_addr)
         return -1;
     }
 
+    virtio_net_hdr_size = vdev->guest_features[1] & VIRTIO_F_VERSION_1
+                          ? VIRTIO_NET_HDR_SIZE_V1
+                          : VIRTIO_NET_HDR_SIZE_LEGACY;
+
     memcpy(mac_addr, vdev->config.net.mac, ETH_ALEN);
 
     for (i = 0; i < 64; i++) {
-        buf = malloc(ETH_MTU_SIZE + sizeof(VirtioNetHdr));
+        buf = malloc(ETH_MTU_SIZE + virtio_net_hdr_size);
         IPL_assert(buf != NULL, "Can not allocate memory for receive buffers");
-        vring_send_buf(rxvq, buf, ETH_MTU_SIZE + sizeof(VirtioNetHdr),
+        vring_send_buf(rxvq, buf, ETH_MTU_SIZE + virtio_net_hdr_size,
                        VRING_DESC_F_WRITE);
     }
     vring_notify(rxvq);
@@ -77,14 +92,14 @@ int virtio_net_init(void *mac_addr)
 
 int send(int fd, const void *buf, int len, int flags)
 {
-    VirtioNetHdr tx_hdr;
+    VirtioNetHdrMrgRxbuf tx_hdr;
     VDev *vdev = virtio_get_device();
     VRing *txvq = &vdev->vrings[VQ_TX];
 
     /* Set up header - we do not use anything special, so simply clear it */
     memset(&tx_hdr, 0, sizeof(tx_hdr));
 
-    vring_send_buf(txvq, &tx_hdr, sizeof(tx_hdr), VRING_DESC_F_NEXT);
+    vring_send_buf(txvq, &tx_hdr, virtio_net_hdr_size, VRING_DESC_F_NEXT);
     vring_send_buf(txvq, (void *)buf, len, VRING_HIDDEN_IS_CHAIN);
     while (!vr_poll(txvq)) {
         yield();
@@ -108,13 +123,13 @@ int recv(int fd, void *buf, int maxlen, int flags)
         return 0;
     }
 
-    len = rxvq->used->ring[rx_last_idx % rxvq->num].len - sizeof(VirtioNetHdr);
+    len = rxvq->used->ring[rx_last_idx % rxvq->num].len - virtio_net_hdr_size;
     if (len > maxlen) {
         puts("virtio-net: Receive buffer too small");
         len = maxlen;
     }
     id = rxvq->used->ring[rx_last_idx % rxvq->num].id % rxvq->num;
-    pkt = (uint8_t *)(rxvq->desc[id].addr + sizeof(VirtioNetHdr));
+    pkt = (uint8_t *)(rxvq->desc[id].addr + virtio_net_hdr_size);
 
 #if DEBUG_VIRTIO_NET   /* Dump packet */
     int i;
-- 
2.55.0

[PULL 13/23] pc-bios/s390-ccw: Introduce virtio_tswap helpers

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Replace the repeated pattern:

    be_ipl() ? x : bswapN(x)

with helpers that conditionally byte-swap based on the virtio transport
endianness.

While only the 16-bit helper is used immediately, the 32-bit and 64-bit
variants are added here for later use.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Reviewed-by: Jason J. Herne <jjherne@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-4-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 pc-bios/s390-ccw/virtio.c | 27 +++++++++++++++++++++------
 pc-bios/s390-ccw/virtio.h |  4 ++++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/pc-bios/s390-ccw/virtio.c b/pc-bios/s390-ccw/virtio.c
index 34c5e6ee22..8949e6c7c0 100644
--- a/pc-bios/s390-ccw/virtio.c
+++ b/pc-bios/s390-ccw/virtio.c
@@ -102,7 +102,7 @@ void vring_init(VRing *vr, VqInfo *info)
     vr->avail->idx = 0;
 
     /* We're running with interrupts off anyways, so don't bother */
-    vr->used->flags = be_ipl() ? VRING_USED_F_NO_NOTIFY : bswap16(VRING_USED_F_NO_NOTIFY);
+    vr->used->flags = virtio_tswap16(VRING_USED_F_NO_NOTIFY);
     vr->used->idx = 0;
     vr->used_idx = 0;
     vr->next_idx = 0;
@@ -143,6 +143,22 @@ bool be_ipl(void)
     }
 }
 
+/* Conditionally byte-swap between virtio-endian and s390x native big-endian. */
+uint16_t virtio_tswap16(uint16_t x)
+{
+    return be_ipl() ? x : bswap16(x);
+}
+
+uint32_t virtio_tswap32(uint32_t x)
+{
+    return be_ipl() ? x : bswap32(x);
+}
+
+uint64_t virtio_tswap64(uint64_t x)
+{
+    return be_ipl() ? x : bswap64(x);
+}
+
 /*
  * Format the virtio ring descriptor endianness
  * Return the available index increment in the appropriate endianness
@@ -159,12 +175,11 @@ void vring_send_buf(VRing *vr, void *p, int len, int flags)
 {
     uint16_t avail_idx;
 
-    avail_idx = be_ipl() ? vr->avail->idx : bswap16(vr->avail->idx);
+    avail_idx = virtio_tswap16(vr->avail->idx);
 
     /* For follow-up chains we need to keep the first entry point */
     if (!(flags & VRING_HIDDEN_IS_CHAIN)) {
-        vr->avail->ring[avail_idx % vr->num] = be_ipl() ? vr->next_idx :
-                                                          bswap16(vr->next_idx);
+        vr->avail->ring[avail_idx % vr->num] = virtio_tswap16(vr->next_idx);
     }
 
     vr->desc[vr->next_idx].addr = (unsigned long)p;
@@ -182,7 +197,7 @@ void vring_send_buf(VRing *vr, void *p, int len, int flags)
     /* Chains only have a single ID */
     if (!(flags & VRING_DESC_F_NEXT)) {
         avail_idx++;
-        vr->avail->idx = be_ipl() ? avail_idx : bswap16(avail_idx);
+        vr->avail->idx = virtio_tswap16(avail_idx);
     }
 }
 
@@ -190,7 +205,7 @@ int vr_poll(VRing *vr)
 {
     uint16_t used_idx;
 
-    used_idx = be_ipl() ? vr->used->idx : bswap16(vr->used->idx);
+    used_idx = virtio_tswap16(vr->used->idx);
     if (used_idx == vr->used_idx) {
         vring_notify(vr);
         yield();
diff --git a/pc-bios/s390-ccw/virtio.h b/pc-bios/s390-ccw/virtio.h
index aa307025e0..645dc288b1 100644
--- a/pc-bios/s390-ccw/virtio.h
+++ b/pc-bios/s390-ccw/virtio.h
@@ -287,6 +287,10 @@ int virtio_run(VDev *vdev, int vqid, VirtioCmd *cmd);
 int virtio_reset(VDev *vdev);
 int virtio_setup_ccw(VDev *vdev);
 
+uint16_t virtio_tswap16(uint16_t x);
+uint32_t virtio_tswap32(uint32_t x);
+uint64_t virtio_tswap64(uint64_t x);
+
 /* virtio-net.c */
 int virtio_net_init(void *mac_addr);
 void virtio_net_deinit(void);
-- 
2.55.0

[PULL 14/23] pc-bios/s390-ccw: Add support for virtio-net-pci IPL

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Enable network booting via virtio-net-pci by implementing PCI transport
support for virtio-net.

This patch also extends endianness handling for virtio PCI ring operations in
little-endian to ensure correct behavior on s390x.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-5-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 pc-bios/s390-ccw/main.c       |  2 ++
 pc-bios/s390-ccw/netmain.c    |  8 ++++++-
 pc-bios/s390-ccw/virtio-net.c | 41 ++++++++++++++++++++++++++++-------
 pc-bios/s390-ccw/virtio-pci.c | 20 +++++++++++++++++
 4 files changed, 62 insertions(+), 9 deletions(-)

diff --git a/pc-bios/s390-ccw/main.c b/pc-bios/s390-ccw/main.c
index d2a2ac3138..b06d67c563 100644
--- a/pc-bios/s390-ccw/main.c
+++ b/pc-bios/s390-ccw/main.c
@@ -342,7 +342,9 @@ static void ipl_pci_device(void)
         return;
     }
 
+    /* net, scsi, and block all intentionally use the same shared boot setup */
     switch (vdev->dev_type) {
+    case VIRTIO_ID_NET:
     case VIRTIO_ID_SCSI:
     case VIRTIO_ID_BLOCK:
         if (virtio_setup() == 0) {
diff --git a/pc-bios/s390-ccw/netmain.c b/pc-bios/s390-ccw/netmain.c
index bcb62bf6ca..dd02c5c71f 100644
--- a/pc-bios/s390-ccw/netmain.c
+++ b/pc-bios/s390-ccw/netmain.c
@@ -498,7 +498,13 @@ int netmain(void)
     sclp_setup();
     puts("Network boot starting...");
 
-    if (!virtio_ccw_net_setup()) {
+    /*
+     * CCW devices require subchannel enumeration here.
+     * PCI devices don't need specific net setup; the virtio-net-pci devices
+     * still follow the regular Virtio, PCI, and generic network setup.
+     */
+    if (virtio_get_device()->ipl_type == S390_IPL_TYPE_CCW &&
+        !virtio_ccw_net_setup()) {
         puts("No valid virtio ccw net device found.");
         return -1;
     }
diff --git a/pc-bios/s390-ccw/virtio-net.c b/pc-bios/s390-ccw/virtio-net.c
index 7bb3f8f551..632ce059d6 100644
--- a/pc-bios/s390-ccw/virtio-net.c
+++ b/pc-bios/s390-ccw/virtio-net.c
@@ -66,7 +66,22 @@ int virtio_net_init(void *mac_addr)
     rx_last_idx = 0;
 
     vdev->guest_features[0] = VIRTIO_NET_F_MAC_BIT;
-    virtio_ccw_setup(vdev);
+    switch (virtio_get_device()->ipl_type) {
+    case S390_IPL_TYPE_CCW:
+        if (virtio_ccw_setup(vdev)) {
+            puts("Setup failed for virtio-net-ccw");
+            return -1;
+        }
+        break;
+    case S390_IPL_TYPE_PCI:
+        if (virtio_pci_setup(vdev)) {
+            puts("Setup failed for virtio-net-pci");
+            return -1;
+        }
+        break;
+    default:
+        return -1;
+    }
 
     if (!(vdev->guest_features[0] & VIRTIO_NET_F_MAC_BIT)) {
         puts("virtio-net device does not support the MAC address feature");
@@ -118,22 +133,30 @@ int recv(int fd, void *buf, int maxlen, int flags)
     VRing *rxvq = &vdev->vrings[VQ_RX];
     int len, id;
     uint8_t *pkt;
+    uint16_t rx_used_idx, rx_avail_idx;
+    uint32_t rx_used_len, rx_used_id;
+    uint64_t rx_desc_addr;
 
-    if (rx_last_idx == rxvq->used->idx) {
+    rx_used_idx = virtio_tswap16(rxvq->used->idx);
+    if (rx_last_idx == rx_used_idx) {
         return 0;
     }
 
-    len = rxvq->used->ring[rx_last_idx % rxvq->num].len - virtio_net_hdr_size;
+    rx_used_len = virtio_tswap32(rxvq->used->ring[rx_last_idx % rxvq->num].len);
+    rx_used_id = virtio_tswap32(rxvq->used->ring[rx_last_idx % rxvq->num].id);
+
+    len = rx_used_len - virtio_net_hdr_size;
     if (len > maxlen) {
         puts("virtio-net: Receive buffer too small");
         len = maxlen;
     }
-    id = rxvq->used->ring[rx_last_idx % rxvq->num].id % rxvq->num;
-    pkt = (uint8_t *)(rxvq->desc[id].addr + virtio_net_hdr_size);
+    id = rx_used_id % rxvq->num;
+    rx_desc_addr = virtio_tswap64(rxvq->desc[id].addr);
+    pkt = (uint8_t *)(rx_desc_addr + virtio_net_hdr_size);
 
 #if DEBUG_VIRTIO_NET   /* Dump packet */
     int i;
-    printf("\nbuf %p: len=%i\n", (void *)rxvq->desc[id].addr, len);
+    printf("\nbuf %p: len=%i\n", (void *)rx_desc_addr, len);
     for (i = 0; i < 64; i++) {
         printf(" %02x", pkt[i]);
         if ((i % 16) == 15) {
@@ -147,8 +170,10 @@ int recv(int fd, void *buf, int maxlen, int flags)
     memcpy(buf, pkt, len);
 
     /* Mark buffer as available to the host again */
-    rxvq->avail->ring[rxvq->avail->idx % rxvq->num] = id;
-    rxvq->avail->idx = rxvq->avail->idx + 1;
+    rx_avail_idx = virtio_tswap16(rxvq->avail->idx);
+    rxvq->avail->ring[rx_avail_idx % rxvq->num] = virtio_tswap16(id);
+    rx_avail_idx++;
+    rxvq->avail->idx = virtio_tswap16(rx_avail_idx);
     vring_notify(rxvq);
 
     /* Move index to next entry */
diff --git a/pc-bios/s390-ccw/virtio-pci.c b/pc-bios/s390-ccw/virtio-pci.c
index 277c3ea68d..eb47e7c534 100644
--- a/pc-bios/s390-ccw/virtio-pci.c
+++ b/pc-bios/s390-ccw/virtio-pci.c
@@ -56,6 +56,10 @@ void virtio_pci_id2type(VDev *vdev, uint16_t device_id)
     case 0x1004:
         vdev->dev_type = VIRTIO_ID_SCSI;
         break;
+    case 0x1041:
+    case 0x1000:
+        vdev->dev_type = VIRTIO_ID_NET;
+        break;
     default:
         vdev->dev_type = 0;
     }
@@ -223,6 +227,17 @@ static int virtio_pci_get_scsi_config(void)
     return rc;
 }
 
+static int virtio_pci_get_net_config(void)
+{
+    VirtioNetConfig *cfg = &virtio_get_device()->config.net;
+
+    /*
+     * Byte-swapping is not needed as only the MAC address (byte array)
+     * is used here. Byte-swap if other fields are added.
+     */
+    return vpci_read_flex(d_cap.off, d_cap.bar, cfg, sizeof(VirtioNetConfig));
+}
+
 static int virtio_pci_negotiate(void)
 {
     int i, rc;
@@ -355,6 +370,7 @@ bool virtio_pci_is_supported(VDev *vdev)
         switch (vdev->dev_type) {
         case VIRTIO_ID_BLOCK:
         case VIRTIO_ID_SCSI:
+        case VIRTIO_ID_NET:
             return true;
         default:
             return false;
@@ -414,6 +430,10 @@ int virtio_pci_setup(VDev *vdev)
         vdev->cmd_vr_idx = 2;
         virtio_pci_get_scsi_config();
         break;
+    case VIRTIO_ID_NET:
+        vdev->nr_vqs = 2;
+        virtio_pci_get_net_config();
+        break;
     default:
         puts("Unsupported virtio device");
         return -ENODEV;
-- 
2.55.0

[PULL 15/23] hw/virtio: Add "loadparm" property to virtio net PCI devices booting on s390x

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Add optional loadparm property to virtio-net-pci to allow boot entry
selection on s390x, consistent with virtio-blk-pci.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Reviewed-by: Jason J. Herne <jjherne@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-6-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/virtio/virtio-net-pci.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/hw/virtio/virtio-net-pci.c b/hw/virtio/virtio-net-pci.c
index fd3e0303f5..893d1905a9 100644
--- a/hw/virtio/virtio-net-pci.c
+++ b/hw/virtio/virtio-net-pci.c
@@ -77,6 +77,7 @@ static void virtio_net_pci_class_init(ObjectClass *klass, const void *data)
     k->sriov_vf_user_creatable = true;
     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
     device_class_set_props(dc, virtio_net_properties);
+    pci_qdev_property_add_specifics(dc);
     vpciklass->realize = virtio_net_pci_realize;
 }
 
-- 
2.55.0

[PULL 16/23] tests/qtest: Check s390x boot device support in pxe-test.c

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

The pxe test for a net device does not fail gracefully when the
s390-ccw.img in use was built without support for booting that device.

Add a boot_dev_support check that searches for a known string in the
bios image to confirm boot support. If absent, the test is skipped
gracefully instead of failing.

Also re-enable pxe-test in qtests_s390x, which was accidentally
removed by commit 973d97feca93.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Tested-by: Joshua Daley <jdaley@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-7-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 tests/qtest/meson.build |  1 +
 tests/qtest/pxe-test.c  | 85 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 85 insertions(+), 1 deletion(-)

diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build
index 33f58b0e95..341f6ad1ba 100644
--- a/tests/qtest/meson.build
+++ b/tests/qtest/meson.build
@@ -292,6 +292,7 @@ qtests_aarch64 = \
    'migration-test']
 
 qtests_s390x = \
+  (slirp.found() ? ['pxe-test'] : []) + \
   qtests_filter + \
   ['boot-serial-test',
    'drive_del-test',
diff --git a/tests/qtest/pxe-test.c b/tests/qtest/pxe-test.c
index e85dec5a4e..5c6415b936 100644
--- a/tests/qtest/pxe-test.c
+++ b/tests/qtest/pxe-test.c
@@ -26,6 +26,7 @@ typedef struct testdef {
     const char *machine;    /* Machine type */
     const char *model;      /* NIC device model */
     const char *extra;      /* Any additional parameters */
+    bool (*boot_dev_support)(void); /* optional: boot device support check */
 } testdef_t;
 
 static testdef_t x86_tests[] = {
@@ -58,8 +59,80 @@ static testdef_t ppc64_tests_slow[] = {
     { NULL },
 };
 
+static const char *s390_bios_load(gsize *len)
+{
+    static char *cached_contents;
+    static gsize cached_len;
+    const char *qemu_bin;
+    g_autofree char *cmd = NULL;
+    char dir[PATH_MAX];
+    char *found = NULL;
+    char *path = NULL;
+    FILE *fp;
+
+    if (cached_contents) {
+        g_test_message("Using cached bios contents");
+        goto out;
+    }
+
+    /* search the qemu binary's data directories for s390-ccw.img */
+    qemu_bin = qtest_qemu_binary(NULL);
+    cmd = g_strdup_printf("%s -L help", qemu_bin);
+    fp = popen(cmd, "r");
+
+    if (!fp) {
+        g_error("Failed to run '%s'", cmd);
+    }
+
+    while (fgets(dir, sizeof(dir), fp) && !found) {
+        dir[strcspn(dir, "\n")] = '\0';
+        path = g_build_filename(dir, "s390-ccw.img", NULL);
+        if (g_file_get_contents(path, &cached_contents, &cached_len, NULL)) {
+            found = path;
+        } else {
+            g_free(path);
+        }
+    }
+    pclose(fp);
+
+    if (!found) {
+        g_error("s390-ccw.img not found");
+    }
+
+    g_test_message("Loaded %s", found);
+    g_free(found);
+
+out:
+    *len = cached_len;
+    return cached_contents;
+}
+
+static bool s390_bios_has_string(const char *needle)
+{
+    const char *contents;
+    gsize len;
+    bool found;
+
+    contents = s390_bios_load(&len);
+    found = memmem(contents, len, needle, strlen(needle)) != NULL;
+
+    g_test_message("\"%s\" %s in bios", needle, found ? "found" : "not found");
+    return found;
+}
+
+static bool s390_bios_has_net_ccw(void)
+{
+    /*
+     * Assume that netboot support always includes virtio-net-ccw support.
+     * Check only that netboot code exists, rather than probing virtio-net-ccw
+     * support directly.
+     */
+    return s390_bios_has_string("Network boot starting...");
+}
+
 static testdef_t s390x_tests[] = {
-    { "s390-ccw-virtio", "virtio-net-ccw" },
+    { "s390-ccw-virtio", "virtio-net-ccw",
+      .boot_dev_support = s390_bios_has_net_ccw },
     { NULL },
 };
 
@@ -90,6 +163,11 @@ static void test_pxe_ipv4(gconstpointer data)
 {
     const testdef_t *test = data;
 
+    if (test->boot_dev_support && !test->boot_dev_support()) {
+        g_test_skip("The bios does not support booting this device");
+        return;
+    }
+
     test_pxe_one(test, false);
 }
 
@@ -97,6 +175,11 @@ static void test_pxe_ipv6(gconstpointer data)
 {
     const testdef_t *test = data;
 
+    if (test->boot_dev_support && !test->boot_dev_support()) {
+        g_test_skip("The bios does not support booting this device");
+        return;
+    }
+
     test_pxe_one(test, true);
 }
 
-- 
2.55.0

Re: [PULL 16/23] tests/qtest: Check s390x boot device support in pxe-test.c

[Bernhard Beschow]

Am 30. September 2026 15:24:13 UTC schrieb Eric Farman <farman@linux.ibm.com>:
>From: Zhuoying Cai <zycai@linux.ibm.com>
>
>The pxe test for a net device does not fail gracefully when the
>s390-ccw.img in use was built without support for booting that device.
>
>Add a boot_dev_support check that searches for a known string in the
>bios image to confirm boot support. If absent, the test is skipped
>gracefully instead of failing.
>
>Also re-enable pxe-test in qtests_s390x, which was accidentally
>removed by commit 973d97feca93.
>
>Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
>Tested-by: Joshua Daley <jdaley@linux.ibm.com>
>Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
>Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-7-zycai@linux.ibm.com
>Signed-off-by: Eric Farman <farman@linux.ibm.com>
>---
> tests/qtest/meson.build |  1 +
> tests/qtest/pxe-test.c  | 85 ++++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 85 insertions(+), 1 deletion(-)
>
>diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build
>index 33f58b0e95..341f6ad1ba 100644
>--- a/tests/qtest/meson.build
>+++ b/tests/qtest/meson.build
>@@ -292,6 +292,7 @@ qtests_aarch64 = \
>    'migration-test']
> 
> qtests_s390x = \
>+  (slirp.found() ? ['pxe-test'] : []) + \
>   qtests_filter + \
>   ['boot-serial-test',
>    'drive_del-test',
>diff --git a/tests/qtest/pxe-test.c b/tests/qtest/pxe-test.c
>index e85dec5a4e..5c6415b936 100644
>--- a/tests/qtest/pxe-test.c
>+++ b/tests/qtest/pxe-test.c
>@@ -26,6 +26,7 @@ typedef struct testdef {
>     const char *machine;    /* Machine type */
>     const char *model;      /* NIC device model */
>     const char *extra;      /* Any additional parameters */
>+    bool (*boot_dev_support)(void); /* optional: boot device support check */
> } testdef_t;
> 
> static testdef_t x86_tests[] = {
>@@ -58,8 +59,80 @@ static testdef_t ppc64_tests_slow[] = {
>     { NULL },
> };
> 
>+static const char *s390_bios_load(gsize *len)
>+{
>+    static char *cached_contents;
>+    static gsize cached_len;
>+    const char *qemu_bin;
>+    g_autofree char *cmd = NULL;
>+    char dir[PATH_MAX];
>+    char *found = NULL;
>+    char *path = NULL;
>+    FILE *fp;
>+
>+    if (cached_contents) {
>+        g_test_message("Using cached bios contents");
>+        goto out;
>+    }
>+
>+    /* search the qemu binary's data directories for s390-ccw.img */
>+    qemu_bin = qtest_qemu_binary(NULL);
>+    cmd = g_strdup_printf("%s -L help", qemu_bin);
>+    fp = popen(cmd, "r");
>+
>+    if (!fp) {
>+        g_error("Failed to run '%s'", cmd);
>+    }
>+
>+    while (fgets(dir, sizeof(dir), fp) && !found) {
>+        dir[strcspn(dir, "\n")] = '\0';
>+        path = g_build_filename(dir, "s390-ccw.img", NULL);
>+        if (g_file_get_contents(path, &cached_contents, &cached_len, NULL)) {
>+            found = path;
>+        } else {
>+            g_free(path);
>+        }
>+    }
>+    pclose(fp);
>+
>+    if (!found) {
>+        g_error("s390-ccw.img not found");
>+    }
>+
>+    g_test_message("Loaded %s", found);
>+    g_free(found);
>+
>+out:
>+    *len = cached_len;
>+    return cached_contents;
>+}
>+
>+static bool s390_bios_has_string(const char *needle)
>+{
>+    const char *contents;
>+    gsize len;
>+    bool found;
>+
>+    contents = s390_bios_load(&len);
>+    found = memmem(contents, len, needle, strlen(needle)) != NULL;

MinGW-w64 has no `memmem`, so this patch unfortunately breaks the MSYS2 build with GCC. We might need to provide our own implementation like we do with other functions: https://lore.kernel.org/qemu-devel/20260216102951.150381-2-kkostiuk@redhat.com/ .

Best regards,
Bernhard

>+
>+    g_test_message("\"%s\" %s in bios", needle, found ? "found" : "not found");
>+    return found;
>+}
>+
>+static bool s390_bios_has_net_ccw(void)
>+{
>+    /*
>+     * Assume that netboot support always includes virtio-net-ccw support.
>+     * Check only that netboot code exists, rather than probing virtio-net-ccw
>+     * support directly.
>+     */
>+    return s390_bios_has_string("Network boot starting...");
>+}
>+
> static testdef_t s390x_tests[] = {
>-    { "s390-ccw-virtio", "virtio-net-ccw" },
>+    { "s390-ccw-virtio", "virtio-net-ccw",
>+      .boot_dev_support = s390_bios_has_net_ccw },
>     { NULL },
> };
> 
>@@ -90,6 +163,11 @@ static void test_pxe_ipv4(gconstpointer data)
> {
>     const testdef_t *test = data;
> 
>+    if (test->boot_dev_support && !test->boot_dev_support()) {
>+        g_test_skip("The bios does not support booting this device");
>+        return;
>+    }
>+
>     test_pxe_one(test, false);
> }
> 
>@@ -97,6 +175,11 @@ static void test_pxe_ipv6(gconstpointer data)
> {
>     const testdef_t *test = data;
> 
>+    if (test->boot_dev_support && !test->boot_dev_support()) {
>+        g_test_skip("The bios does not support booting this device");
>+        return;
>+    }
>+
>     test_pxe_one(test, true);
> }
> 

Re: [PULL 16/23] tests/qtest: Check s390x boot device support in pxe-test.c

[Eric Farman]

On 10/7/26 4:02 PM, Bernhard Beschow wrote:
> 
> 
> Am 30. September 2026 15:24:13 UTC schrieb Eric Farman <farman@linux.ibm.com>:
>> From: Zhuoying Cai <zycai@linux.ibm.com>
>>
>> The pxe test for a net device does not fail gracefully when the
>> s390-ccw.img in use was built without support for booting that device.
>>
>> Add a boot_dev_support check that searches for a known string in the
>> bios image to confirm boot support. If absent, the test is skipped
>> gracefully instead of failing.
>>
>> Also re-enable pxe-test in qtests_s390x, which was accidentally
>> removed by commit 973d97feca93.
>>
>> Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
>> Tested-by: Joshua Daley <jdaley@linux.ibm.com>
>> Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
>> Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-7-zycai@linux.ibm.com
>> Signed-off-by: Eric Farman <farman@linux.ibm.com>
>> ---
>> tests/qtest/meson.build |  1 +
>> tests/qtest/pxe-test.c  | 85 ++++++++++++++++++++++++++++++++++++++++-
>> 2 files changed, 85 insertions(+), 1 deletion(-)
>>
>> diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build
>> index 33f58b0e95..341f6ad1ba 100644
>> --- a/tests/qtest/meson.build
>> +++ b/tests/qtest/meson.build
>> @@ -292,6 +292,7 @@ qtests_aarch64 = \
>>     'migration-test']
>>
>> qtests_s390x = \
>> +  (slirp.found() ? ['pxe-test'] : []) + \
>>    qtests_filter + \
>>    ['boot-serial-test',
>>     'drive_del-test',
>> diff --git a/tests/qtest/pxe-test.c b/tests/qtest/pxe-test.c
>> index e85dec5a4e..5c6415b936 100644
>> --- a/tests/qtest/pxe-test.c
>> +++ b/tests/qtest/pxe-test.c
>> @@ -26,6 +26,7 @@ typedef struct testdef {
>>      const char *machine;    /* Machine type */
>>      const char *model;      /* NIC device model */
>>      const char *extra;      /* Any additional parameters */
>> +    bool (*boot_dev_support)(void); /* optional: boot device support check */
>> } testdef_t;
>>
>> static testdef_t x86_tests[] = {
>> @@ -58,8 +59,80 @@ static testdef_t ppc64_tests_slow[] = {
>>      { NULL },
>> };
>>
>> +static const char *s390_bios_load(gsize *len)
>> +{
>> +    static char *cached_contents;
>> +    static gsize cached_len;
>> +    const char *qemu_bin;
>> +    g_autofree char *cmd = NULL;
>> +    char dir[PATH_MAX];
>> +    char *found = NULL;
>> +    char *path = NULL;
>> +    FILE *fp;
>> +
>> +    if (cached_contents) {
>> +        g_test_message("Using cached bios contents");
>> +        goto out;
>> +    }
>> +
>> +    /* search the qemu binary's data directories for s390-ccw.img */
>> +    qemu_bin = qtest_qemu_binary(NULL);
>> +    cmd = g_strdup_printf("%s -L help", qemu_bin);
>> +    fp = popen(cmd, "r");
>> +
>> +    if (!fp) {
>> +        g_error("Failed to run '%s'", cmd);
>> +    }
>> +
>> +    while (fgets(dir, sizeof(dir), fp) && !found) {
>> +        dir[strcspn(dir, "\n")] = '\0';
>> +        path = g_build_filename(dir, "s390-ccw.img", NULL);
>> +        if (g_file_get_contents(path, &cached_contents, &cached_len, NULL)) {
>> +            found = path;
>> +        } else {
>> +            g_free(path);
>> +        }
>> +    }
>> +    pclose(fp);
>> +
>> +    if (!found) {
>> +        g_error("s390-ccw.img not found");
>> +    }
>> +
>> +    g_test_message("Loaded %s", found);
>> +    g_free(found);
>> +
>> +out:
>> +    *len = cached_len;
>> +    return cached_contents;
>> +}
>> +
>> +static bool s390_bios_has_string(const char *needle)
>> +{
>> +    const char *contents;
>> +    gsize len;
>> +    bool found;
>> +
>> +    contents = s390_bios_load(&len);
>> +    found = memmem(contents, len, needle, strlen(needle)) != NULL;
> 
> MinGW-w64 has no `memmem`, so this patch unfortunately breaks the MSYS2 build with GCC. We might need to provide our own implementation like we do with other functions: https://lore.kernel.org/qemu-devel/20260216102951.150381-2-kkostiuk@redhat.com/ .

Oof, sorry about that! Thanks for the report; will work with Joy and 
Matt to get this repaired. (And I'll figure out why I didn't stumble on 
this in my build tests.)

Thanks,
Eric

> 
> Best regards,
> Bernhard
> 
>> +
>> +    g_test_message("\"%s\" %s in bios", needle, found ? "found" : "not found");
>> +    return found;
>> +}
>> +
>> +static bool s390_bios_has_net_ccw(void)
>> +{
>> +    /*
>> +     * Assume that netboot support always includes virtio-net-ccw support.
>> +     * Check only that netboot code exists, rather than probing virtio-net-ccw
>> +     * support directly.
>> +     */
>> +    return s390_bios_has_string("Network boot starting...");
>> +}
>> +
>> static testdef_t s390x_tests[] = {
>> -    { "s390-ccw-virtio", "virtio-net-ccw" },
>> +    { "s390-ccw-virtio", "virtio-net-ccw",
>> +      .boot_dev_support = s390_bios_has_net_ccw },
>>      { NULL },
>> };
>>
>> @@ -90,6 +163,11 @@ static void test_pxe_ipv4(gconstpointer data)
>> {
>>      const testdef_t *test = data;
>>
>> +    if (test->boot_dev_support && !test->boot_dev_support()) {
>> +        g_test_skip("The bios does not support booting this device");
>> +        return;
>> +    }
>> +
>>      test_pxe_one(test, false);
>> }
>>
>> @@ -97,6 +175,11 @@ static void test_pxe_ipv6(gconstpointer data)
>> {
>>      const testdef_t *test = data;
>>
>> +    if (test->boot_dev_support && !test->boot_dev_support()) {
>> +        g_test_skip("The bios does not support booting this device");
>> +        return;
>> +    }
>> +
>>      test_pxe_one(test, true);
>> }
>>

[PULL 17/23] tests/qtest: Add s390x virtio net PCI test to pxe-test.c

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Add test coverage for virtio-net-pci network booting on s390x by
including it in the PXE test suite. The test verifies that PXE
network booting works correctly with virtio-net-pci devices.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Tested-by: Joshua Daley <jdaley@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-8-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 tests/qtest/pxe-test.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/qtest/pxe-test.c b/tests/qtest/pxe-test.c
index 5c6415b936..61c92a2df4 100644
--- a/tests/qtest/pxe-test.c
+++ b/tests/qtest/pxe-test.c
@@ -130,9 +130,20 @@ static bool s390_bios_has_net_ccw(void)
     return s390_bios_has_string("Network boot starting...");
 }
 
+static bool s390_bios_has_net_pci(void)
+{
+    /*
+     * Check for a string unique to virtio-net-pci boot support in the bios
+     * to determine if the binary was built with support for this device.
+     */
+    return s390_bios_has_string("Setup failed for virtio-net-pci");
+}
+
 static testdef_t s390x_tests[] = {
     { "s390-ccw-virtio", "virtio-net-ccw",
       .boot_dev_support = s390_bios_has_net_ccw },
+    { "s390-ccw-virtio", "virtio-net-pci",
+      .boot_dev_support = s390_bios_has_net_pci },
     { NULL },
 };
 
-- 
2.55.0

[PULL 18/23] tests/functional/s390x: Add tests for virtio net PCI in test_pxelinux.py

[Eric Farman]

From: Zhuoying Cai <zycai@linux.ibm.com>

Add test coverage for virtio-net-pci network booting on s390x by
extending the pxelinux functional tests.

This patch adds PCI variants of all existing pxelinux tests to verify
that virtio-net-pci devices work correctly for network booting.

Signed-off-by: Zhuoying Cai <zycai@linux.ibm.com>
Tested-by: Joshua Daley <jdaley@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Jared Rossi <jrossi@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260924222949.147720-9-zycai@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 tests/functional/s390x/test_pxelinux.py | 71 ++++++++++++++++++++-----
 1 file changed, 59 insertions(+), 12 deletions(-)

diff --git a/tests/functional/s390x/test_pxelinux.py b/tests/functional/s390x/test_pxelinux.py
index c00cce6a5a..5ce42aa074 100755
--- a/tests/functional/s390x/test_pxelinux.py
+++ b/tests/functional/s390x/test_pxelinux.py
@@ -50,7 +50,8 @@ class S390PxeLinux(QemuSystemTest):
          '/images/kernel.img'),
         '480859574f3f44caa6cd35c62d70e1ac0609134e22ce2a954bbed9b110c06e0b')
 
-    def pxelinux_launch(self, pl_name='default', extra_opts=None):
+    def pxelinux_launch(self, pl_name='default', extra_opts=None,
+                        dev='virtio-net-ccw'):
         '''Create a pxelinux.cfg file in the right location and launch QEMU'''
         self.require_netdev('user')
         self.set_machine('s390-ccw-virtio')
@@ -74,7 +75,7 @@ def pxelinux_launch(self, pl_name='default', extra_opts=None):
         with open(cfg_fname, 'w', encoding='utf-8') as f:
             f.write(PXELINUX_CFG_CONTENTS)
 
-        virtio_net_dev = 'virtio-net-ccw,netdev=n1,bootindex=1'
+        virtio_net_dev = f'{dev},netdev=n1,bootindex=1'
         if extra_opts:
             virtio_net_dev += ',' + extra_opts
 
@@ -85,9 +86,9 @@ def pxelinux_launch(self, pl_name='default', extra_opts=None):
         self.vm.launch()
 
 
-    def test_default(self):
+    def do_test_default(self, dev):
         '''Check whether the guest uses the "default" file name'''
-        self.pxelinux_launch()
+        self.pxelinux_launch(dev=dev)
         # The kernel prints its arguments to the console, so we can use
         # this to check whether the kernel parameters are correctly handled:
         wait_for_console_pattern(self, 'testoption=teststring')
@@ -95,36 +96,82 @@ def test_default(self):
         wait_for_console_pattern(self, 'Unpacking initramfs...')
         wait_for_console_pattern(self, 'Run /init as init process')
 
-    def test_mac(self):
+    def do_test_mac(self, dev):
         '''Check whether the guest uses file name based on its MAC address'''
         self.pxelinux_launch(pl_name='01-02-ca-fe-ba-be-42',
-                             extra_opts='mac=02:ca:fe:ba:be:42,loadparm=3')
+                             extra_opts='mac=02:ca:fe:ba:be:42,loadparm=3',
+                             dev=dev)
         wait_for_console_pattern(self, 'Linux version 5.3.7-301.fc31.s390x')
 
-    def test_uuid(self):
+    def do_test_uuid(self, dev):
         '''Check whether the guest uses file name based on its UUID'''
         # Also add a non-bootable disk to check the fallback to network boot:
         self.vm.add_args('-blockdev', 'null-co,size=65536,node-name=d1',
                          '-device', 'virtio-blk,drive=d1,bootindex=0,loadparm=1',
                          '-uuid', '550e8400-e29b-11d4-a716-446655441234')
-        self.pxelinux_launch(pl_name='550e8400-e29b-11d4-a716-446655441234')
+        self.pxelinux_launch(pl_name='550e8400-e29b-11d4-a716-446655441234',
+                             dev=dev)
         wait_for_console_pattern(self, 'Debian 4.19.146-1 (2020-09-17)')
 
-    def test_ip(self):
+    def do_test_ip(self, dev):
         '''Check whether the guest uses file name based on its IP address'''
         self.vm.add_args('-M', 'loadparm=3')
-        self.pxelinux_launch(pl_name='0A00020F')
+        self.pxelinux_launch(pl_name='0A00020F', dev=dev)
         wait_for_console_pattern(self, 'Linux version 5.3.7-301.fc31.s390x')
 
-    def test_menu(self):
+    def do_test_menu(self, dev):
         '''Check whether the boot menu works for pxelinux.cfg booting'''
         self.vm.add_args('-boot', 'menu=on,splash-time=10')
-        self.pxelinux_launch(pl_name='0A00')
+        self.pxelinux_launch(pl_name='0A00', dev=dev)
         wait_for_console_pattern(self, '[1] Nonexisting')
         wait_for_console_pattern(self, '[2] Debian')
         wait_for_console_pattern(self, '[3] Fedora')
         wait_for_console_pattern(self, 'Debian 4.19.146-1 (2020-09-17)')
 
+    def test_default_ccw(self):
+        '''pxelinux.cfg "default" lookup via virtio-net-ccw'''
+        self.do_test_default('virtio-net-ccw')
+
+    def test_default_pci(self):
+        '''pxelinux.cfg "default" lookup via virtio-net-pci'''
+        self.require_device('virtio-net-pci')
+        self.do_test_default('virtio-net-pci')
+
+    def test_mac_ccw(self):
+        '''pxelinux.cfg MAC-address-based file lookup via virtio-net-ccw'''
+        self.do_test_mac('virtio-net-ccw')
+
+    def test_mac_pci(self):
+        '''pxelinux.cfg MAC-address-based file lookup via virtio-net-pci'''
+        self.require_device('virtio-net-pci')
+        self.do_test_mac('virtio-net-pci')
+
+    def test_uuid_ccw(self):
+        '''pxelinux.cfg UUID-based file lookup via virtio-net-ccw'''
+        self.do_test_uuid('virtio-net-ccw')
+
+    def test_uuid_pci(self):
+        '''pxelinux.cfg UUID-based file lookup via virtio-net-pci'''
+        self.require_device('virtio-net-pci')
+        self.do_test_uuid('virtio-net-pci')
+
+    def test_ip_ccw(self):
+        '''pxelinux.cfg IP-address-based file lookup via virtio-net-ccw'''
+        self.do_test_ip('virtio-net-ccw')
+
+    def test_ip_pci(self):
+        '''pxelinux.cfg IP-address-based file lookup via virtio-net-pci'''
+        self.require_device('virtio-net-pci')
+        self.do_test_ip('virtio-net-pci')
+
+    def test_menu_ccw(self):
+        '''pxelinux.cfg interactive boot menu via virtio-net-ccw'''
+        self.do_test_menu('virtio-net-ccw')
+
+    def test_menu_pci(self):
+        '''pxelinux.cfg interactive boot menu via virtio-net-pci'''
+        self.require_device('virtio-net-pci')
+        self.do_test_menu('virtio-net-pci')
 
 if __name__ == '__main__':
     QemuSystemTest.main()
-- 
2.55.0

[PULL 19/23] s390x/sclpconsole: fix indentation for console_reset

[Eric Farman]

From: Maximilian Immanuel Brandtner <maxbr@linux.ibm.com>

Adjust indentation to match the rest of the file. No functional change
intended.

Signed-off-by: Maximilian Immanuel Brandtner <maxbr@linux.ibm.com>
Reviewed-by: Matthew Rosato <mjrosato@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260929152012.2696005-2-maxbr@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/char/sclpconsole.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/hw/char/sclpconsole.c b/hw/char/sclpconsole.c
index 179d12745c..1ad39084d3 100644
--- a/hw/char/sclpconsole.c
+++ b/hw/char/sclpconsole.c
@@ -240,15 +240,15 @@ static int console_init(SCLPEvent *event)
 
 static void console_reset(DeviceState *dev)
 {
-   SCLPEvent *event = SCLP_EVENT(dev);
-   SCLPConsole *scon = SCLP_CONSOLE(event);
-
-   event->event_pending = false;
-   scon->iov_sclp = 0;
-   scon->iov_bs = 0;
-   scon->iov_data_len = 0;
-   scon->iov_sclp_rest = 0;
-   scon->notify = false;
+    SCLPEvent *event = SCLP_EVENT(dev);
+    SCLPConsole *scon = SCLP_CONSOLE(event);
+
+    event->event_pending = false;
+    scon->iov_sclp = 0;
+    scon->iov_bs = 0;
+    scon->iov_data_len = 0;
+    scon->iov_sclp_rest = 0;
+    scon->notify = false;
 }
 
 static const Property console_properties[] = {
-- 
2.55.0

[PULL 20/23] s390x/pci: Fix frame stepping in rpcit_service_call()

[Eric Farman]

From: Matthew Rosato <mjrosato@linux.ibm.com>

When walking the guest IO address table, an invalid segment or region
entry causes table_translate() to return entry.len equal to the frame
size for that table level (1 MiB for ST, 2 GiB for RT).  Adding
entry.len directly to start only advances to the correct next frame
boundary if start is already frame-aligned at that level -- which is
true for a well-behaved Linux guest but not a general requirement.

Add logic to advance start to the next frame boundary rather than
simply adding entry.len.  For a frame-aligned start (the typical,
well-behaved case) the result is identical.

Fixes: 0125861eacc3 ("s390x/pci: fixup the code walking IOMMU tables")
Cc: qemu-stable@nongnu.org
Signed-off-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Eric Farman <farman@linux.ibm.com>
Reviewed-by: Farhan Ali <alifm@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260929153012.774530-2-mjrosato@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/s390-pci-inst.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/hw/s390x/s390-pci-inst.c b/hw/s390x/s390-pci-inst.c
index 652e1712ec..bac813fb6a 100644
--- a/hw/s390x/s390-pci-inst.c
+++ b/hw/s390x/s390-pci-inst.c
@@ -808,7 +808,8 @@ int rpcit_service_call(S390CPU *cpu, uint8_t r1, uint8_t r2, uintptr_t ra)
             coalesce = 0;
         }
 
-        start += entry.len;
+        /* Advance to next frame boundary if start was not frame-aligned */
+        start = QEMU_ALIGN_UP(start + 1, entry.len);
         while (entry.iova < start && entry.iova < end) {
             if (dma_avail > 0 || entry.perm == IOMMU_NONE) {
                 dma_avail = s390_pci_update_iotlb(iommu, &entry);
-- 
2.55.0

[PULL 21/23] s390x/pci: Use qemu_log_mask() for guest-triggered errors in reg_ioat()

[Eric Farman]

From: Matthew Rosato <mjrosato@linux.ibm.com>

The error paths in reg_ioat() that are triggered by a guest providing
invalid MPCIFC arguments use error_report(), which writes unconditionally
to stderr.  A misbehaving guest can exploit this to flood the host log
by repeatedly issuing the instruction with bad arguments.

Replace these with qemu_log_mask(LOG_GUEST_ERROR, ...) so that the
messages are suppressible.

Fixes: 863f6f52b713 ("s390: implement pci instructions")
Fixes: dfcee1ea4c52 ("s390x/pci: add support for guests that request direct mapping")
Cc: qemu-stable@nongnu.org
Signed-off-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Farhan Ali <alifm@linux.ibm.com>
Reviewed-by: Eric Farman <farman@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260929153012.774530-3-mjrosato@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/s390-pci-inst.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/hw/s390x/s390-pci-inst.c b/hw/s390x/s390-pci-inst.c
index bac813fb6a..73417edade 100644
--- a/hw/s390x/s390-pci-inst.c
+++ b/hw/s390x/s390-pci-inst.c
@@ -15,8 +15,8 @@
 #include "exec/memop.h"
 #include "exec/target_page.h"
 #include "system/memory.h"
-#include "qemu/error-report.h"
 #include "qemu/bswap.h"
+#include "qemu/log.h"
 #include "system/hw_accel.h"
 #include "hw/core/boards.h"
 #include "hw/pci/pci_device.h"
@@ -1044,11 +1044,12 @@ static int reg_ioat(CPUS390XState *env, S390PCIBusDevice *pbdev, ZpciFib fib,
 
     /* currently we only support designation type 1 with translation */
     if (t && dt != ZPCI_IOTA_RTTO) {
-        error_report("unsupported ioat dt %d t %d", dt, t);
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "unsupported ioat dt %d t %d\n", dt, t);
         s390_program_interrupt(env, PGM_OPERAND, ra);
         return -EINVAL;
     } else if (!t && !pbdev->rtr_avail) {
-        error_report("relaxed translation not allowed");
+        qemu_log_mask(LOG_GUEST_ERROR, "relaxed translation not allowed\n");
         s390_program_interrupt(env, PGM_OPERAND, ra);
         return -EINVAL;
     }
-- 
2.55.0

[PULL 22/23] s390x/pci: Reject apertures beyond IOAT capacity in translation mode

[Eric Farman]

From: Matthew Rosato <mjrosato@linux.ibm.com>

In order to support direct mapping (which is only bound by the aperture
size of the underlying host EDMA reported via vfio) QEMU reports the
host-provided EDMA to the guest.  However, when using translation mode
QEMU only supports up to 4 TiB currently (the size of a single RT
table).

Reject attempts by a guest to register a translation aperture that
would exceed what QEMU can support by giving an operand exception on
the MPCIFC instruction that requested the large aperture.  This
restriction can be removed in the future if/when support for additional
IOAT regions is added.

Cc: qemu-stable@nongnu.org
Signed-off-by: Matthew Rosato <mjrosato@linux.ibm.com>
Reviewed-by: Farhan Ali <alifm@linux.ibm.com>
Link: https://lore.kernel.org/qemu-devel/20260929153012.774530-4-mjrosato@linux.ibm.com
Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 hw/s390x/s390-pci-inst.c        | 15 +++++++++++++++
 include/hw/s390x/s390-pci-bus.h |  1 +
 2 files changed, 16 insertions(+)

diff --git a/hw/s390x/s390-pci-inst.c b/hw/s390x/s390-pci-inst.c
index 73417edade..09026360d4 100644
--- a/hw/s390x/s390-pci-inst.c
+++ b/hw/s390x/s390-pci-inst.c
@@ -1054,6 +1054,21 @@ static int reg_ioat(CPUS390XState *env, S390PCIBusDevice *pbdev, ZpciFib fib,
         return -EINVAL;
     }
 
+    /*
+     * We report an EDMA that may exceed what QEMU can handle in support
+     * of direct-mapping.  If the guest attempts to register an IOAT that
+     * is too large, reject it with an informative message.  Only direct
+     * mapping can be used for guests of this size until support is added
+     * to QEMU for additional IOAT regions.
+     */
+    if (t && pal >= ZPCI_TABLE_SIZE_RT) {
+        qemu_log_mask(LOG_GUEST_ERROR,
+                      "ioat pal 0x%"PRIx64" exceeds max translatable address\n",
+                      pal);
+        s390_program_interrupt(env, PGM_OPERAND, ra);
+        return -EINVAL;
+    }
+
     iommu->pba = pba;
     iommu->pal = pal;
     iommu->g_iota = g_iota;
diff --git a/include/hw/s390x/s390-pci-bus.h b/include/hw/s390x/s390-pci-bus.h
index 9228523ce8..f182bab246 100644
--- a/include/hw/s390x/s390-pci-bus.h
+++ b/include/hw/s390x/s390-pci-bus.h
@@ -140,6 +140,7 @@ enum ZpciIoatDtype {
 #define ZPCI_PT_BITS            8
 #define ZPCI_ST_SHIFT           (ZPCI_PT_BITS + TARGET_PAGE_BITS)
 #define ZPCI_RT_SHIFT           (ZPCI_ST_SHIFT + ZPCI_TABLE_BITS)
+#define ZPCI_TABLE_SIZE_RT      (1ULL << (ZPCI_RT_SHIFT + ZPCI_TABLE_BITS))
 
 #define ZPCI_RTE_FLAG_MASK      0x3fffULL
 #define ZPCI_RTE_ADDR_MASK      (~ZPCI_RTE_FLAG_MASK)
-- 
2.55.0

[PULL 23/23] pc-bios/s390-ccw.img: update s390x bios

[Eric Farman]

Rebuild bios to include:

 - 20260924222949.147720-1-zycai@linux.ibm.com

Signed-off-by: Eric Farman <farman@linux.ibm.com>
---
 pc-bios/s390-ccw.img | Bin 112408 -> 112408 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/pc-bios/s390-ccw.img b/pc-bios/s390-ccw.img
index 7dd262b8992bb68718c1f1a5fe96727e230b3868..bb07d2d9eefe6b1e22abec9b5b52e9381be63de6 100644
GIT binary patch
delta 27171
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
KZF-NbW&Z~Y5uc0z

delta 26116
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
M@QP<&XY1Ji0|=9{#Q*>R

-- 
2.55.0

Re: [PULL 00/23] s390x queue

[Richard Henderson]

On 9/30/26 16:23, Eric Farman wrote:
> The following changes since commit 3876503faff51ce3a132dbbd0ab42c10f2269319:
> 
>    Merge tag 'target-misc-20260924' ofhttps://github.com/philmd/qemu into staging (2026-09-24 13:30:19 -0700)
> 
> are available in the Git repository at:
> 
>    https://gitlab.com/efarman/qemu.git tags/s390x-20260930
> 
> for you to fetch changes up to cf8299050666ee84ee400a3a0195be7598850e93:
> 
>    pc-bios/s390-ccw.img: update s390x bios (2026-09-30 09:09:14 -0400)
> 
> ----------------------------------------------------------------
> New s390x features for 11.2
>   - enable boot via virtio-net-pci
>   - PCI and SCLP fixes
>   - hardening fixes throughout
>   - regenerate s390-ccw.img
> 

Applied, thanks.

r~