fridtjof/qemu-cr16
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

migration: Fix regression of passing error_fatal into vmstate_load_state()

Browse source 
error_fatal is passed to vmstate_load_state() and vmstate_save_state()
functions. This was introduced in commit c632ffbd74. This would exit(1)
on error, and therefore does not allow to propagate the error back to
the caller.

To maintain consistency with prior error handling i.e. either propagating
the error to the caller or reporting it, we must set the error within a
local Error object instead of using error_fatal.

Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
Reviewed-by: Akihiko Odaki <odaki@rsg.ci.i.u-tokyo.ac.jp>
Link: https://lore.kernel.org/r/20251028-solve_error_fatal_regression-v2-1-dab24c808a28@redhat.com
[peterx: always uninit var ret, per Akihiko]
[peterx: touchups on line ordering, spacings etc.]
Signed-off-by: Peter Xu <peterx@redhat.com>
This commit is contained in:
Arun Menon 2025-10-28 11:51:02 +05:30 • committed by Peter Xu
parent 75e2cb1441
commit 986c3292c6
7 changed files with 83 additions and 20 deletions
Download patch file Download diff file Expand all files Collapse all files

21
hw/display/virtio-gpu.c
View file

@ -1225,7 +1225,8 @@ static int virtio_gpu_save(QEMUFile *f, void *opaque, size_t size,
{
VirtIOGPU *g = opaque;
struct virtio_gpu_simple_resource *res;
int i;
Error *err = NULL;
int i, ret;
/* in 2d mode we should never find unprocessed commands here */
assert(QTAILQ_EMPTY(&g->cmdq));
@ -1248,8 +1249,12 @@ static int virtio_gpu_save(QEMUFile *f, void *opaque, size_t size,
}
qemu_put_be32(f, 0); /* end of list */
return vmstate_save_state(f, &vmstate_virtio_gpu_scanouts, g, NULL,
&error_fatal);
ret = vmstate_save_state(f, &vmstate_virtio_gpu_scanouts, g, NULL,
&err);
if (ret < 0) {
error_report_err(err);
}
return ret;
}
static bool virtio_gpu_load_restore_mapping(VirtIOGPU *g,
@ -1288,7 +1293,7 @@ static int virtio_gpu_load(QEMUFile *f, void *opaque, size_t size,
Error *err = NULL;
struct virtio_gpu_simple_resource *res;
uint32_t resource_id, pformat;
int i;
int i, ret;
g->hostmem = 0;
@ -1348,9 +1353,11 @@ static int virtio_gpu_load(QEMUFile *f, void *opaque, size_t size,
}
/* load & apply scanout state */
vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, &error_fatal);
return 0;
ret = vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, &err);
if (ret < 0) {
error_report_err(err);
}
return ret;
}
static int virtio_gpu_blob_save(QEMUFile *f, void *opaque, size_t size,

15
hw/pci/pci.c
View file

@ -921,21 +921,32 @@ const VMStateDescription vmstate_pci_device = {
void pci_device_save(PCIDevice *s, QEMUFile *f)
{
Error *local_err = NULL;
int ret;
/* Clear interrupt status bit: it is implicit
* in irq_state which we are saving.
* This makes us compatible with old devices
* which never set or clear this bit. */
s->config[PCI_STATUS] &= ~PCI_STATUS_INTERRUPT;
vmstate_save_state(f, &vmstate_pci_device, s, NULL, &error_fatal);
ret = vmstate_save_state(f, &vmstate_pci_device, s, NULL, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
/* Restore the interrupt status bit. */
pci_update_irq_status(s);
}
int pci_device_load(PCIDevice *s, QEMUFile *f)
{
Error *local_err = NULL;
int ret;
ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id,
&error_fatal);
&local_err);
if (ret < 0) {
error_report_err(local_err);
}
/* Restore the interrupt status bit. */
pci_update_irq_status(s);
return ret;

17
hw/s390x/virtio-ccw.c
View file

@ -1130,13 +1130,26 @@ static int virtio_ccw_load_queue(DeviceState *d, int n, QEMUFile *f)
static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
vmstate_save_state(f, &vmstate_virtio_ccw_dev, dev, NULL, &error_fatal);
Error *local_err = NULL;
int ret;
ret = vmstate_save_state(f, &vmstate_virtio_ccw_dev, dev, NULL, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
}
static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, &error_fatal);
Error *local_err = NULL;
int ret;
ret = vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
return ret;
}
static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)

10
hw/scsi/spapr_vscsi.c
View file

@ -628,10 +628,16 @@ static const VMStateDescription vmstate_spapr_vscsi_req = {
static void vscsi_save_request(QEMUFile *f, SCSIRequest *sreq)
{
vscsi_req *req = sreq->hba_private;
Error *local_err = NULL;
int rc;
assert(req->active);
vmstate_save_state(f, &vmstate_spapr_vscsi_req, req, NULL, &error_fatal);
rc = vmstate_save_state(f, &vmstate_spapr_vscsi_req, req, NULL, &local_err);
if (rc < 0) {
error_report_err(local_err);
return;
}
trace_spapr_vscsi_save_request(req->qtag, req->cur_desc_num,
req->cur_desc_offset);
}

15
hw/virtio/virtio-mmio.c
View file

@ -612,15 +612,26 @@ static const VMStateDescription vmstate_virtio_mmio = {
static void virtio_mmio_save_extra_state(DeviceState *opaque, QEMUFile *f)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
Error *local_err = NULL;
int ret;
vmstate_save_state(f, &vmstate_virtio_mmio, proxy, NULL, &error_fatal);
ret = vmstate_save_state(f, &vmstate_virtio_mmio, proxy, NULL, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
}
static int virtio_mmio_load_extra_state(DeviceState *opaque, QEMUFile *f)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
Error *local_err = NULL;
int ret;
return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, &error_fatal);
ret = vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
return ret;
}
static bool virtio_mmio_has_extra_state(DeviceState *opaque)

15
hw/virtio/virtio-pci.c
View file

@ -187,15 +187,26 @@ static bool virtio_pci_has_extra_state(DeviceState *d)
static void virtio_pci_save_extra_state(DeviceState *d, QEMUFile *f)
{
VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
Error *local_err = NULL;
int ret;
vmstate_save_state(f, &vmstate_virtio_pci, proxy, NULL, &error_fatal);
ret = vmstate_save_state(f, &vmstate_virtio_pci, proxy, NULL, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
}
static int virtio_pci_load_extra_state(DeviceState *d, QEMUFile *f)
{
VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
Error *local_err = NULL;
int ret;
return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, &error_fatal);
ret = vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
return ret;
}
static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)

10
hw/virtio/virtio.c
View file

@ -3030,7 +3030,7 @@ int virtio_save(VirtIODevice *vdev, QEMUFile *f)
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
uint32_t guest_features_lo = (vdev->guest_features & 0xffffffff);
int i;
int i, ret;
Error *local_err = NULL;
if (k->save_config) {
@ -3075,7 +3075,7 @@ int virtio_save(VirtIODevice *vdev, QEMUFile *f)
}
if (vdc->vmsd) {
int ret = vmstate_save_state(f, vdc->vmsd, vdev, NULL, &local_err);
ret = vmstate_save_state(f, vdc->vmsd, vdev, NULL, &local_err);
if (ret) {
error_report_err(local_err);
return ret;
@ -3083,7 +3083,11 @@ int virtio_save(VirtIODevice *vdev, QEMUFile *f)
}
/* Subsections */
return vmstate_save_state(f, &vmstate_virtio, vdev, NULL, &error_fatal);
ret = vmstate_save_state(f, &vmstate_virtio, vdev, NULL, &local_err);
if (ret < 0) {
error_report_err(local_err);
}
return ret;
}
/* A wrapper for use as a VMState .put function */