[PATCH v7 00/24] migration: propagate vTPM errors using Error objects

[PATCH v7 00/24] migration: propagate vTPM errors using Error objects

[Arun Menon]

Hello,

Currently, when a migration of a VM with an encrypted vTPM
fails on the destination host (e.g., due to a mismatch in secret values),
the error message displayed on the source host is generic and unhelpful.

For example, a typical error looks like this:
"operation failed: job 'migration out' failed: Sibling indicated error 1.
operation failed: job 'migration in' failed: load of migration failed:
Input/output error"

This message does not provide any specific indication of a vTPM failure.
Such generic errors are logged using error_report(), which prints to
the console/monitor but does not make the detailed error accessible via
the QMP query-migrate command.

This series addresses the issue, by ensuring that specific TPM error
messages are propagated via the QEMU Error object.
To make this possible,
- A set of functions in the call stack is changed
  to incorporate an Error object as an additional parameter.
- Also, the TPM backend makes use of a new hook called post_load_errp()
  that explicitly passes an Error object.

It is organized as follows,
 - Patches 1-21 focuses on pushing Error object into the functions
   that are important in the call stack where TPM errors are observed.
   We still need to make changes in rest of the functions in savevm.c
   such that they also incorporate the errp object for propagating errors.
 - Patch 22 introduces the new variants of the hooks in VMStateDescription
   structure. These hooks should be used in future implementations.
 - Patch 23 focuses on changing the TPM backend such that the errors are
   set in the Error object.

While this series focuses specifically on TPM error reporting during
live migration, it lays the groundwork for broader improvements.
A lot of methods in savevm.c that previously returned an integer now capture
errors in the Error object, enabling other modules to adopt the
post_load_errp hook in the future.

One such change previously attempted:
https://lists.gnu.org/archive/html/qemu-devel/2021-02/msg01727.html

Resolves: https://issues.redhat.com/browse/RHEL-82826

Signed-off-by: Arun Menon <armenon@redhat.com>
---
Changes in v7:
- Fix propagating errors in post_save_errp. The latest error encountered is
  propagated.
- user-strings in error_prepend() calls now end with a ': ' so that the print is pretty.
- Change the order of one of the patches.
- Link to v6: https://lore.kernel.org/qemu-devel/20250721-propagate_tpm_error-v6-0-fef740e15e17@redhat.com

Changes in v6:
- Incorporated review comments from Daniel and Akihiko, related to few
  semantic errors and improve error logging.
- Add one more patch that removes NULL checks after calling 
  qemu_file_get_return_path() because it does not fail.
- Link to v5: https://lore.kernel.org/qemu-devel/20250717-propagate_tpm_error-v5-0-1f406f88ee65@redhat.com

Changes in v5:
- Solve a bug that set errp even though it was not NULL, pointed out by Fabiano in v4.
- Link to v4: https://lore.kernel.org/qemu-devel/20250716-propagate_tpm_error-v4-0-7141902077c0@redhat.com

Changes in v4:
- Split the patches into smaller ones based on functions. Pass NULL in the
  caller until errp is made available. Every function that has an
  Error **errp object passed to it, ensures that it sets the errp object
  in case of failure.
- A few more functions within loadvm_process_command() now handle errors using
  the errp object. I've converted these for consistency, taking Daniel's
  patches (link above) as a reference.
- Along with the post_load_errp() hook, other duplicate hooks are also introduced.
  This will enable us to migrate to the newer versions eventually.
- Fix some semantic errors, like using error_propagate_prepend() in places where
  we need to preserve existing behaviour of accumulating the error in local_err
  and then propagating it to errp. This can be refactored in a later commit.
- Add more information in commit messages explaining the changes.
- Link to v3: https://lore.kernel.org/qemu-devel/20250702-propagate_tpm_error-v3-0-986d94540528@redhat.com

Changes in v3:
- Split the 2nd patch into 2. Introducing post_load_with_error() hook
  has been separated from using it in the backends TPM module. This is
  so that it can be acknowledged.
- Link to v2: https://lore.kernel.org/qemu-devel/20250627-propagate_tpm_error-v2-0-85990c89da29@redhat.com

Changes in v2:
- Combine the first two changes into one, focusing on passing the
  Error object (errp) consistently through functions involved in
  loading the VM's state. Other functions are not yet changed.
- As suggested in the review comment, add null checks for errp
  before adding error messages, preventing crashes.
  We also now correctly set errors when post-copy migration fails.
- In process_incoming_migration_co(), switch to error_prepend
  instead of error_setg. This means we now null-check local_err in
  the "fail" section before using it, preventing dereferencing issues.
- Link to v1: https://lore.kernel.org/qemu-devel/20250624-propagate_tpm_error-v1-0-2171487a593d@redhat.com

---
Arun Menon (24):
      migration: push Error **errp into vmstate_subsection_load()
      migration: push Error **errp into vmstate_load_state()
      migration: push Error **errp into qemu_loadvm_state_header()
      migration: push Error **errp into vmstate_load()
      migration: push Error **errp into qemu_loadvm_section_start_full()
      migration: push Error **errp into qemu_loadvm_section_part_end()
      migration: Update qemu_file_get_return_path() docs and remove dead checks
      migration: make loadvm_postcopy_handle_resume() void
      migration: push Error **errp into loadvm_process_command()
      migration: push Error **errp into loadvm_handle_cmd_packaged()
      migration: push Error **errp into ram_postcopy_incoming_init()
      migration: push Error **errp into loadvm_postcopy_handle_advise()
      migration: push Error **errp into loadvm_postcopy_handle_listen()
      migration: push Error **errp into loadvm_postcopy_handle_run()
      migration: push Error **errp into loadvm_postcopy_ram_handle_discard()
      migration: push Error **errp into loadvm_handle_recv_bitmap()
      migration: push Error **errp into loadvm_process_enable_colo()
      migration: push Error **errp into loadvm_postcopy_handle_switchover_start()
      migration: push Error **errp into qemu_loadvm_state_main()
      migration: push Error **errp into qemu_loadvm_state()
      migration: push Error **errp into qemu_load_device_state()
      migration: Capture error in postcopy_ram_listen_thread()
      migration: Add error-parameterized function variants in VMSD struct
      backends/tpm: Propagate vTPM error on migration failure

 backends/tpm/tpm_emulator.c |  39 +++---
 hw/display/virtio-gpu.c     |   2 +-
 hw/pci/pci.c                |   2 +-
 hw/s390x/virtio-ccw.c       |   2 +-
 hw/scsi/spapr_vscsi.c       |   2 +-
 hw/vfio/pci.c               |   2 +-
 hw/virtio/virtio-mmio.c     |   2 +-
 hw/virtio/virtio-pci.c      |   2 +-
 hw/virtio/virtio.c          |   4 +-
 include/migration/colo.h    |   2 +-
 include/migration/vmstate.h |  13 +-
 migration/colo.c            |  12 +-
 migration/cpr.c             |   4 +-
 migration/migration.c       |  31 ++---
 migration/postcopy-ram.c    |   9 +-
 migration/postcopy-ram.h    |   2 +-
 migration/qemu-file.c       |   1 -
 migration/ram.c             |  12 +-
 migration/ram.h             |   4 +-
 migration/savevm.c          | 316 +++++++++++++++++++++++++-------------------
 migration/savevm.h          |   7 +-
 migration/vmstate-types.c   |  10 +-
 migration/vmstate.c         | 114 ++++++++++++----
 tests/unit/test-vmstate.c   |  18 +--
 ui/vdagent.c                |   2 +-
 25 files changed, 365 insertions(+), 249 deletions(-)
---
base-commit: 9e601684dc24a521bb1d23215a63e5c6e79ea0bb
change-id: 20250624-propagate_tpm_error-bf4ae6c23d30

Best regards,
-- 
Arun Menon <armenon@redhat.com>

[PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that vmstate_subsection_load() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/vmstate.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/migration/vmstate.c b/migration/vmstate.c
index 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b 100644
--- a/migration/vmstate.c
+++ b/migration/vmstate.c
@@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
                                    void *opaque, JSONWriter *vmdesc,
                                    Error **errp);
 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
-                                   void *opaque);
+                                   void *opaque, Error **errp);
 
 /* Whether this field should exist for either save or load the VM? */
 static bool
@@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
         field++;
     }
     assert(field->flags == VMS_END);
-    ret = vmstate_subsection_load(f, vmsd, opaque);
+    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
     if (ret != 0) {
         qemu_file_set_error(f, ret);
         return ret;
@@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription * const *sub,
 }
 
 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
-                                   void *opaque)
+                                   void *opaque, Error **errp)
 {
     trace_vmstate_subsection_load(vmsd->name);
 
@@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
         sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
         if (sub_vmsd == NULL) {
             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
+            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
+                       idstr, vmsd->name);
             return -ENOENT;
         }
         qemu_file_skip(f, 1); /* subsection */
@@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
         ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
         if (ret) {
             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
+            error_setg(errp,
+                       "Loading VM subsection '%s' in '%s' failed : %d",
+                       idstr, vmsd->name, ret);
             return ret;
         }
     }

-- 
2.50.0

[PATCH v7 02/24] migration: push Error **errp into vmstate_load_state()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that vmstate_load_state() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 hw/display/virtio-gpu.c     |  2 +-
 hw/pci/pci.c                |  2 +-
 hw/s390x/virtio-ccw.c       |  2 +-
 hw/scsi/spapr_vscsi.c       |  2 +-
 hw/vfio/pci.c               |  2 +-
 hw/virtio/virtio-mmio.c     |  2 +-
 hw/virtio/virtio-pci.c      |  2 +-
 hw/virtio/virtio.c          |  4 ++--
 include/migration/vmstate.h |  2 +-
 migration/cpr.c             |  4 ++--
 migration/savevm.c          |  6 ++++--
 migration/vmstate-types.c   | 10 ++++-----
 migration/vmstate.c         | 49 ++++++++++++++++++++++++++++-----------------
 tests/unit/test-vmstate.c   | 18 ++++++++---------
 ui/vdagent.c                |  2 +-
 15 files changed, 62 insertions(+), 47 deletions(-)

diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c
index 0a1a625b0ea6cf26cb0d799171a57ed3d3ab2442..5d2ca8d8b864350133a674802d7316abd379591c 100644
--- a/hw/display/virtio-gpu.c
+++ b/hw/display/virtio-gpu.c
@@ -1343,7 +1343,7 @@ 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);
+    vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, NULL);
 
     return 0;
 }
diff --git a/hw/pci/pci.c b/hw/pci/pci.c
index c70b5ceebaf1f2b10768bd030526cbb518da2b8d..2ab5d30bb3c319ac1c7bfc9a2acf6a2b38082066 100644
--- a/hw/pci/pci.c
+++ b/hw/pci/pci.c
@@ -934,7 +934,7 @@ void pci_device_save(PCIDevice *s, QEMUFile *f)
 int pci_device_load(PCIDevice *s, QEMUFile *f)
 {
     int ret;
-    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id);
+    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id, NULL);
     /* Restore the interrupt status bit. */
     pci_update_irq_status(s);
     return ret;
diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
index d2f85b39f30f7fc82e0c600144c0a958e1269b2c..2f6feff2b0a22d7d7f6aecfd7e7870d8362f1a73 100644
--- a/hw/s390x/virtio-ccw.c
+++ b/hw/s390x/virtio-ccw.c
@@ -1136,7 +1136,7 @@ static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f)
 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);
+    return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, NULL);
 }
 
 static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c
index 20f70fb2729de78b9636a6b8c869695dab4f8902..573fdea668536b464bca11f001e9e0288e781493 100644
--- a/hw/scsi/spapr_vscsi.c
+++ b/hw/scsi/spapr_vscsi.c
@@ -648,7 +648,7 @@ static void *vscsi_load_request(QEMUFile *f, SCSIRequest *sreq)
     assert(!req->active);
 
     memset(req, 0, sizeof(*req));
-    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1);
+    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1, NULL);
     if (rc) {
         fprintf(stderr, "VSCSI: failed loading request tag#%u\n", sreq->tag);
         return NULL;
diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
index e72d514a4cb91946f7c79332492bf5d709c308f2..498bbb96e97df50af5fc906fa00d4436c1edc05f 100644
--- a/hw/vfio/pci.c
+++ b/hw/vfio/pci.c
@@ -2797,7 +2797,7 @@ static int vfio_pci_load_config(VFIODevice *vbasedev, QEMUFile *f)
         old_addr[bar] = pdev->io_regions[bar].addr;
     }
 
-    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1);
+    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1, NULL);
     if (ret) {
         return ret;
     }
diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c
index 532c67107ba1d2978a76cf49f9cdc1de1dea3e11..9058b1563462d4464dcba799643a583c93fb5683 100644
--- a/hw/virtio/virtio-mmio.c
+++ b/hw/virtio/virtio-mmio.c
@@ -619,7 +619,7 @@ static int virtio_mmio_load_extra_state(DeviceState *opaque, QEMUFile *f)
 {
     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
 
-    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1);
+    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, NULL);
 }
 
 static bool virtio_mmio_has_extra_state(DeviceState *opaque)
diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
index 767216d795998708f5716a23ae16c79cd90ff489..f8b52a611e56c22d844fd4cae3619da4f2686d03 100644
--- a/hw/virtio/virtio-pci.c
+++ b/hw/virtio/virtio-pci.c
@@ -161,7 +161,7 @@ static int virtio_pci_load_extra_state(DeviceState *d, QEMUFile *f)
 {
     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 
-    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1);
+    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, NULL);
 }
 
 static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index 2ab1d20769495ea39445b87e3673b076ad172510..d5698b062a1e95437f6113f41136e90ae06f1974 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -3317,14 +3317,14 @@ virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id)
     }
 
     if (vdc->vmsd) {
-        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id);
+        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id, NULL);
         if (ret) {
             return ret;
         }
     }
 
     /* Subsections */
-    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
+    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1, NULL);
     if (ret) {
         return ret;
     }
diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
index 1ff7bd9ac425ba67cd5ca7ad97bcf570f9e19abe..056781b1c21e737583f081594d9f88b32adfd674 100644
--- a/include/migration/vmstate.h
+++ b/include/migration/vmstate.h
@@ -1196,7 +1196,7 @@ extern const VMStateInfo vmstate_info_qlist;
     }
 
 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
-                       void *opaque, int version_id);
+                       void *opaque, int version_id, Error **errp);
 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
                        void *opaque, JSONWriter *vmdesc);
 int vmstate_save_state_with_err(QEMUFile *f, const VMStateDescription *vmsd,
diff --git a/migration/cpr.c b/migration/cpr.c
index 42ad0b0d500e5de57faf0c6517e216b2d1c0cacf..9569c3f76bf8714def6406ae24f7fbc5afa4e793 100644
--- a/migration/cpr.c
+++ b/migration/cpr.c
@@ -233,9 +233,9 @@ int cpr_state_load(MigrationChannel *channel, Error **errp)
         return -ENOTSUP;
     }
 
-    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1);
+    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1, errp);
     if (ret) {
-        error_setg(errp, "vmstate_load_state error %d", ret);
+        error_prepend(errp, "vmstate_load_state error %d: ", ret);
         qemu_fclose(f);
         return ret;
     }
diff --git a/migration/savevm.c b/migration/savevm.c
index fabbeb296ae987d0c06ba6dafda63720205fecfd..ab947620f724874f325fb9fb59bef50b7c16fb51 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -969,7 +969,8 @@ static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
     if (!se->vmsd) {         /* Old style */
         return se->ops->load_state(f, se->opaque, se->load_version_id);
     }
-    return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id);
+    return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id,
+                              NULL);
 }
 
 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
@@ -2839,7 +2840,8 @@ static int qemu_loadvm_state_header(QEMUFile *f)
             error_report("Configuration section missing");
             return -EINVAL;
         }
-        ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0);
+        ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0,
+                                 NULL);
 
         if (ret) {
             return ret;
diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c
index 741a588b7e18c6d37724b08a0101edc8bc74a0a5..1c5b76e1dd198030847971bc35637867c9d54fc0 100644
--- a/migration/vmstate-types.c
+++ b/migration/vmstate-types.c
@@ -549,7 +549,7 @@ static int get_tmp(QEMUFile *f, void *pv, size_t size,
 
     /* Writes the parent field which is at the start of the tmp */
     *(void **)tmp = pv;
-    ret = vmstate_load_state(f, vmsd, tmp, version_id);
+    ret = vmstate_load_state(f, vmsd, tmp, version_id, NULL);
     g_free(tmp);
     return ret;
 }
@@ -649,7 +649,7 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t unused_size,
 
     while (qemu_get_byte(f)) {
         elm = g_malloc(size);
-        ret = vmstate_load_state(f, vmsd, elm, version_id);
+        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
         if (ret) {
             return ret;
         }
@@ -803,7 +803,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t unused_size,
             key = (void *)(uintptr_t)qemu_get_be64(f);
         } else {
             key = g_malloc0(key_size);
-            ret = vmstate_load_state(f, key_vmsd, key, version_id);
+            ret = vmstate_load_state(f, key_vmsd, key, version_id, NULL);
             if (ret) {
                 error_report("%s : failed to load %s (%d)",
                              field->name, key_vmsd->name, ret);
@@ -811,7 +811,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t unused_size,
             }
         }
         val = g_malloc0(val_size);
-        ret = vmstate_load_state(f, val_vmsd, val, version_id);
+        ret = vmstate_load_state(f, val_vmsd, val, version_id, NULL);
         if (ret) {
             error_report("%s : failed to load %s (%d)",
                          field->name, val_vmsd->name, ret);
@@ -892,7 +892,7 @@ static int get_qlist(QEMUFile *f, void *pv, size_t unused_size,
 
     while (qemu_get_byte(f)) {
         elm = g_malloc(size);
-        ret = vmstate_load_state(f, vmsd, elm, version_id);
+        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
         if (ret) {
             error_report("%s: failed to load %s (%d)", field->name,
                          vmsd->name, ret);
diff --git a/migration/vmstate.c b/migration/vmstate.c
index aeffeafaa4fa7582076a4f2747906ddf9aca891b..bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb 100644
--- a/migration/vmstate.c
+++ b/migration/vmstate.c
@@ -132,29 +132,33 @@ static void vmstate_handle_alloc(void *ptr, const VMStateField *field,
 }
 
 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
-                       void *opaque, int version_id)
+                       void *opaque, int version_id, Error **errp)
 {
     const VMStateField *field = vmsd->fields;
     int ret = 0;
 
     trace_vmstate_load_state(vmsd->name, version_id);
     if (version_id > vmsd->version_id) {
-        error_report("%s: incoming version_id %d is too new "
-                     "for local version_id %d",
-                     vmsd->name, version_id, vmsd->version_id);
+        error_setg(errp, "%s: incoming version_id %d is too new "
+                   "for local version_id %d",
+                   vmsd->name, version_id, vmsd->version_id);
         trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
         return -EINVAL;
     }
     if  (version_id < vmsd->minimum_version_id) {
-        error_report("%s: incoming version_id %d is too old "
-                     "for local minimum version_id  %d",
-                     vmsd->name, version_id, vmsd->minimum_version_id);
+        error_setg(errp, "%s: incoming version_id %d is too old "
+                   "for local minimum version_id  %d",
+                   vmsd->name, version_id, vmsd->minimum_version_id);
         trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
         return -EINVAL;
     }
     if (vmsd->pre_load) {
         ret = vmsd->pre_load(opaque);
         if (ret) {
+            error_setg(errp, "VM pre load failed for: '%s', "
+                       "version_id: '%d', minimum version_id: '%d', ret: %d",
+                       vmsd->name, vmsd->version_id, vmsd->minimum_version_id,
+                       ret);
             return ret;
         }
     }
@@ -192,10 +196,12 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
 
                 if (inner_field->flags & VMS_STRUCT) {
                     ret = vmstate_load_state(f, inner_field->vmsd, curr_elem,
-                                             inner_field->vmsd->version_id);
+                                             inner_field->vmsd->version_id,
+                                             errp);
                 } else if (inner_field->flags & VMS_VSTRUCT) {
                     ret = vmstate_load_state(f, inner_field->vmsd, curr_elem,
-                                             inner_field->struct_version_id);
+                                             inner_field->struct_version_id,
+                                             errp);
                 } else {
                     ret = inner_field->info->get(f, curr_elem, size,
                                                  inner_field);
@@ -211,27 +217,34 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
                 }
                 if (ret < 0) {
                     qemu_file_set_error(f, ret);
-                    error_report("Failed to load %s:%s", vmsd->name,
-                                 field->name);
+                    error_prepend(errp, "Failed to load %s:%s version_id: %d: ",
+                                  vmsd->name, field->name, vmsd->version_id);
                     trace_vmstate_load_field_error(field->name, ret);
                     return ret;
                 }
             }
         } else if (field->flags & VMS_MUST_EXIST) {
-            error_report("Input validation failed: %s/%s",
-                         vmsd->name, field->name);
+            error_setg(errp, "Input validation failed: %s/%s version_id: %d",
+                       vmsd->name, field->name, vmsd->version_id);
             return -1;
         }
         field++;
     }
     assert(field->flags == VMS_END);
-    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
+    ret = vmstate_subsection_load(f, vmsd, opaque, errp);
     if (ret != 0) {
         qemu_file_set_error(f, ret);
         return ret;
     }
     if (vmsd->post_load) {
         ret = vmsd->post_load(opaque, version_id);
+        if (ret < 0) {
+            error_setg(errp,
+                       "VM Post load failed for: %s, version_id: %d, "
+                       "minimum_version: %d, ret: %d",
+                       vmsd->name, vmsd->version_id, vmsd->minimum_version_id,
+                       ret);
+        }
     }
     trace_vmstate_load_state_end(vmsd->name, "end", ret);
     return ret;
@@ -607,12 +620,12 @@ static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
         qemu_file_skip(f, len); /* idstr */
         version_id = qemu_get_be32(f);
 
-        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
+        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id, errp);
         if (ret) {
             trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
-            error_setg(errp,
-                       "Loading VM subsection '%s' in '%s' failed : %d",
-                       idstr, vmsd->name, ret);
+            error_prepend(errp,
+                          "Loading VM subsection '%s' in '%s' failed: '%d': ",
+                          idstr, vmsd->name, ret);
             return ret;
         }
     }
diff --git a/tests/unit/test-vmstate.c b/tests/unit/test-vmstate.c
index 63f28f26f45691a70936d33e7341d16477a3471f..ca5e0ba1e3e5e2bb0a1ce39143a292f2c6f9420a 100644
--- a/tests/unit/test-vmstate.c
+++ b/tests/unit/test-vmstate.c
@@ -114,7 +114,7 @@ static int load_vmstate_one(const VMStateDescription *desc, void *obj,
     qemu_fclose(f);
 
     f = open_test_file(false);
-    ret = vmstate_load_state(f, desc, obj, version);
+    ret = vmstate_load_state(f, desc, obj, version, NULL);
     if (ret) {
         g_assert(qemu_file_get_error(f));
     } else{
@@ -365,7 +365,7 @@ static void test_load_v1(void)
 
     QEMUFile *loading = open_test_file(false);
     TestStruct obj = { .b = 200, .e = 500, .f = 600 };
-    vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
+    vmstate_load_state(loading, &vmstate_versioned, &obj, 1, NULL);
     g_assert(!qemu_file_get_error(loading));
     g_assert_cmpint(obj.a, ==, 10);
     g_assert_cmpint(obj.b, ==, 200);
@@ -391,7 +391,7 @@ static void test_load_v2(void)
 
     QEMUFile *loading = open_test_file(false);
     TestStruct obj;
-    vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
+    vmstate_load_state(loading, &vmstate_versioned, &obj, 2, NULL);
     g_assert_cmpint(obj.a, ==, 10);
     g_assert_cmpint(obj.b, ==, 20);
     g_assert_cmpint(obj.c, ==, 30);
@@ -480,7 +480,7 @@ static void test_load_noskip(void)
 
     QEMUFile *loading = open_test_file(false);
     TestStruct obj = { .skip_c_e = false };
-    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
+    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
     g_assert(!qemu_file_get_error(loading));
     g_assert_cmpint(obj.a, ==, 10);
     g_assert_cmpint(obj.b, ==, 20);
@@ -504,7 +504,7 @@ static void test_load_skip(void)
 
     QEMUFile *loading = open_test_file(false);
     TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
-    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
+    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
     g_assert(!qemu_file_get_error(loading));
     g_assert_cmpint(obj.a, ==, 10);
     g_assert_cmpint(obj.b, ==, 20);
@@ -773,7 +773,7 @@ static void test_load_q(void)
     TestQtailq tgt;
 
     QTAILQ_INIT(&tgt.q);
-    vmstate_load_state(fload, &vmstate_q, &tgt, 1);
+    vmstate_load_state(fload, &vmstate_q, &tgt, 1, NULL);
     char eof = qemu_get_byte(fload);
     g_assert(!qemu_file_get_error(fload));
     g_assert_cmpint(tgt.i16, ==, obj_q.i16);
@@ -1127,7 +1127,7 @@ static void test_gtree_load_domain(void)
 
     fload = open_test_file(false);
 
-    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1);
+    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1, NULL);
     eof = qemu_get_byte(fload);
     g_assert(!qemu_file_get_error(fload));
     g_assert_cmpint(orig_domain->id, ==, dest_domain->id);
@@ -1241,7 +1241,7 @@ static void test_gtree_load_iommu(void)
     qemu_fclose(fsave);
 
     fload = open_test_file(false);
-    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1);
+    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1, NULL);
     eof = qemu_get_byte(fload);
     g_assert(!qemu_file_get_error(fload));
     g_assert_cmpint(orig_iommu->id, ==, dest_iommu->id);
@@ -1376,7 +1376,7 @@ static void test_load_qlist(void)
     qemu_fclose(fsave);
 
     fload = open_test_file(false);
-    vmstate_load_state(fload, &vmstate_container, dest_container, 1);
+    vmstate_load_state(fload, &vmstate_container, dest_container, 1, NULL);
     eof = qemu_get_byte(fload);
     g_assert(!qemu_file_get_error(fload));
     g_assert_cmpint(eof, ==, QEMU_VM_EOF);
diff --git a/ui/vdagent.c b/ui/vdagent.c
index c0746fe5b168fdc7aeb4866de2ba0c3387566649..83457dee0767433ad0778b37b41b9c673a0e1860 100644
--- a/ui/vdagent.c
+++ b/ui/vdagent.c
@@ -1008,7 +1008,7 @@ static int get_cbinfo(QEMUFile *f, void *pv, size_t size,
 
     vdagent_clipboard_peer_register(vd);
 
-    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0);
+    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0, NULL);
     if (ret) {
         return ret;
     }

-- 
2.50.0

[PATCH v7 03/24] migration: push Error **errp into qemu_loadvm_state_header()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_loadvm_state_header() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index ab947620f724874f325fb9fb59bef50b7c16fb51..842ff3dc6d5ccb05f7d33cef9f7319b141419501 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2814,35 +2814,44 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
     return 0;
 }
 
-static int qemu_loadvm_state_header(QEMUFile *f)
+static int qemu_loadvm_state_header(QEMUFile *f, Error **errp)
 {
     unsigned int v;
     int ret;
 
     v = qemu_get_be32(f);
     if (v != QEMU_VM_FILE_MAGIC) {
-        error_report("Not a migration stream");
+        error_setg(errp, "Not a migration stream, magic: %x != %x",
+                   v, QEMU_VM_FILE_MAGIC);
         return -EINVAL;
     }
 
     v = qemu_get_be32(f);
     if (v == QEMU_VM_FILE_VERSION_COMPAT) {
-        error_report("SaveVM v2 format is obsolete and don't work anymore");
+        error_setg(errp,
+                   "SaveVM v2 format is obsolete and no longer supported, "
+                   "file version %x != %x",
+                   v, QEMU_VM_FILE_VERSION_COMPAT);
+
         return -ENOTSUP;
     }
     if (v != QEMU_VM_FILE_VERSION) {
-        error_report("Unsupported migration stream version");
+        error_setg(errp, "Unsupported migration stream version, "
+                   "file version %x != %x",
+                   v, QEMU_VM_FILE_VERSION);
         return -ENOTSUP;
     }
 
     if (migrate_get_current()->send_configuration) {
-        if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
-            error_report("Configuration section missing");
+        v = qemu_get_byte(f);
+        if (v != QEMU_VM_CONFIGURATION) {
+            error_setg(errp, "Configuration section missing, %x != %x",
+                       v, QEMU_VM_CONFIGURATION);
             return -EINVAL;
         }
-        ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0,
-                                 NULL);
 
+        ret = vmstate_load_state(f, &vmstate_configuration, &savevm_state, 0,
+                                 errp);
         if (ret) {
             return ret;
         }
@@ -3119,7 +3128,7 @@ int qemu_loadvm_state(QEMUFile *f)
 
     qemu_loadvm_thread_pool_create(mis);
 
-    ret = qemu_loadvm_state_header(f);
+    ret = qemu_loadvm_state_header(f, NULL);
     if (ret) {
         return ret;
     }

-- 
2.50.0

[PATCH v7 04/24] migration: push Error **errp into vmstate_load()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that vmstate_load() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 842ff3dc6d5ccb05f7d33cef9f7319b141419501..736410be867a29efa24d749528c9bc203a3e8131 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -963,14 +963,20 @@ void vmstate_unregister(VMStateIf *obj, const VMStateDescription *vmsd,
     }
 }
 
-static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
+static int vmstate_load(QEMUFile *f, SaveStateEntry *se, Error **errp)
 {
+    int ret;
     trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
     if (!se->vmsd) {         /* Old style */
-        return se->ops->load_state(f, se->opaque, se->load_version_id);
+        ret = se->ops->load_state(f, se->opaque, se->load_version_id);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load VM version_id: '%d', ret: '%d'",
+                       se->load_version_id, ret);
+        }
+        return ret;
     }
     return vmstate_load_state(f, se->vmsd, se->opaque, se->load_version_id,
-                              NULL);
+                              errp);
 }
 
 static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
@@ -2741,7 +2747,7 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
         start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
     }
 
-    ret = vmstate_load(f, se);
+    ret = vmstate_load(f, se, NULL);
     if (ret < 0) {
         error_report("error while loading state for instance 0x%"PRIx32" of"
                      " device '%s'", instance_id, idstr);
@@ -2794,7 +2800,7 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
         start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
     }
 
-    ret = vmstate_load(f, se);
+    ret = vmstate_load(f, se, NULL);
     if (ret < 0) {
         error_report("error while loading state section id %d(%s)",
                      section_id, se->idstr);

-- 
2.50.0

[PATCH v7 05/24] migration: push Error **errp into qemu_loadvm_section_start_full()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_loadvm_section_start_full() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 736410be867a29efa24d749528c9bc203a3e8131..29d2947eed79432f7bd9224743549aad87d177b9 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2690,7 +2690,7 @@ static bool check_section_footer(QEMUFile *f, SaveStateEntry *se)
 }
 
 static int
-qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
+qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type, Error **errp)
 {
     bool trace_downtime = (type == QEMU_VM_SECTION_FULL);
     uint32_t instance_id, version_id, section_id;
@@ -2702,8 +2702,8 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
     /* Read section start */
     section_id = qemu_get_be32(f);
     if (!qemu_get_counted_string(f, idstr)) {
-        error_report("Unable to read ID string for section %u",
-                     section_id);
+        error_setg(errp, "Unable to read ID string for section %u",
+                   section_id);
         return -EINVAL;
     }
     instance_id = qemu_get_be32(f);
@@ -2711,8 +2711,7 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
 
     ret = qemu_file_get_error(f);
     if (ret) {
-        error_report("%s: Failed to read instance/version ID: %d",
-                     __func__, ret);
+        error_setg(errp, "Failed to read instance/version ID: %d", ret);
         return ret;
     }
 
@@ -2721,17 +2720,17 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
     /* Find savevm section */
     se = find_se(idstr, instance_id);
     if (se == NULL) {
-        error_report("Unknown savevm section or instance '%s' %"PRIu32". "
-                     "Make sure that your current VM setup matches your "
-                     "saved VM setup, including any hotplugged devices",
-                     idstr, instance_id);
+        error_setg(errp, "Unknown savevm section or instance '%s' %"PRIu32". "
+                   "Make sure that your current VM setup matches your "
+                   "saved VM setup, including any hotplugged devices",
+                   idstr, instance_id);
         return -EINVAL;
     }
 
     /* Validate version */
     if (version_id > se->version_id) {
-        error_report("savevm: unsupported version %d for '%s' v%d",
-                     version_id, idstr, se->version_id);
+        error_setg(errp, "savevm: unsupported version %d for '%s' v%d",
+                   version_id, idstr, se->version_id);
         return -EINVAL;
     }
     se->load_version_id = version_id;
@@ -2739,7 +2738,7 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
 
     /* Validate if it is a device's state */
     if (xen_enabled() && se->is_ram) {
-        error_report("loadvm: %s RAM loading not allowed on Xen", idstr);
+        error_setg(errp, "loadvm: %s RAM loading not allowed on Xen", idstr);
         return -EINVAL;
     }
 
@@ -2747,10 +2746,11 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
         start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
     }
 
-    ret = vmstate_load(f, se, NULL);
+    ret = vmstate_load(f, se, errp);
     if (ret < 0) {
-        error_report("error while loading state for instance 0x%"PRIx32" of"
-                     " device '%s'", instance_id, idstr);
+        error_prepend(errp,
+                      "error while loading state for instance 0x%"PRIx32" of"
+                      " device '%s': ", instance_id, idstr);
         return ret;
     }
 
@@ -2761,6 +2761,9 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type)
     }
 
     if (!check_section_footer(f, se)) {
+        error_setg(errp, "Reading footer section of instance "
+                   "0x%"PRIx32" of device '%s' for version_id:'%d' failed",
+                   instance_id, idstr, version_id);
         return -EINVAL;
     }
 
@@ -3063,7 +3066,7 @@ retry:
         switch (section_type) {
         case QEMU_VM_SECTION_START:
         case QEMU_VM_SECTION_FULL:
-            ret = qemu_loadvm_section_start_full(f, section_type);
+            ret = qemu_loadvm_section_start_full(f, section_type, NULL);
             if (ret < 0) {
                 goto out;
             }

-- 
2.50.0

[PATCH v7 06/24] migration: push Error **errp into qemu_loadvm_section_part_end()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_loadvm_section_part_end() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 29d2947eed79432f7bd9224743549aad87d177b9..21899e6beee3d2661c9a694379039e82cefbee4f 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2771,7 +2771,7 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t type, Error **errp)
 }
 
 static int
-qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
+qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type, Error **errp)
 {
     bool trace_downtime = (type == QEMU_VM_SECTION_END);
     int64_t start_ts, end_ts;
@@ -2783,8 +2783,7 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
 
     ret = qemu_file_get_error(f);
     if (ret) {
-        error_report("%s: Failed to read section ID: %d",
-                     __func__, ret);
+        error_setg(errp, "Failed to read section ID: %d", ret);
         return ret;
     }
 
@@ -2795,7 +2794,7 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
         }
     }
     if (se == NULL) {
-        error_report("Unknown savevm section %d", section_id);
+        error_setg(errp, "Unknown savevm section %d", section_id);
         return -EINVAL;
     }
 
@@ -2803,10 +2802,10 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
         start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
     }
 
-    ret = vmstate_load(f, se, NULL);
+    ret = vmstate_load(f, se, errp);
     if (ret < 0) {
-        error_report("error while loading state section id %d(%s)",
-                     section_id, se->idstr);
+        error_prepend(errp, "error while loading state section id %d(%s): ",
+                      section_id, se->idstr);
         return ret;
     }
 
@@ -2817,6 +2816,8 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t type)
     }
 
     if (!check_section_footer(f, se)) {
+        error_setg(errp, "Check section footer error, section_id: '%d'",
+                   section_id);
         return -EINVAL;
     }
 
@@ -3073,7 +3074,7 @@ retry:
             break;
         case QEMU_VM_SECTION_PART:
         case QEMU_VM_SECTION_END:
-            ret = qemu_loadvm_section_part_end(f, section_type);
+            ret = qemu_loadvm_section_part_end(f, section_type, NULL);
             if (ret < 0) {
                 goto out;
             }

-- 
2.50.0

[PATCH v7 07/24] migration: Update qemu_file_get_return_path() docs and remove dead checks

[Arun Menon]

The documentation of qemu_file_get_return_path() states that it can
return NULL on failure. However, a review of the current implementation
reveals that it is guaranteed that it will always succeed and will never
return NULL.

As a result, the NULL checks post calling the function become redundant.
This commit updates the documentation for the function and removes all
NULL checks throughout the migration code.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/colo.c      |  4 ----
 migration/migration.c | 12 ++----------
 migration/qemu-file.c |  1 -
 migration/savevm.c    |  4 ----
 4 files changed, 2 insertions(+), 19 deletions(-)

diff --git a/migration/colo.c b/migration/colo.c
index e0f713c837f5da25d67afbd02ceb6c54024ca3af..981bd4bf9ced8b45b4c5d494acae119a174ee974 100644
--- a/migration/colo.c
+++ b/migration/colo.c
@@ -849,10 +849,6 @@ static void *colo_process_incoming_thread(void *opaque)
     failover_init_state();
 
     mis->to_src_file = qemu_file_get_return_path(mis->from_src_file);
-    if (!mis->to_src_file) {
-        error_report("COLO incoming thread: Open QEMUFile to_src_file failed");
-        goto out;
-    }
     /*
      * Note: the communication between Primary side and Secondary side
      * should be sequential, we set the fd to unblocked in migration incoming
diff --git a/migration/migration.c b/migration/migration.c
index 10c216d25dec01f206eacad2edd24d21f00e614c..b3bccaeaee806abd01595863f6475057049b0688 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -2646,12 +2646,9 @@ out:
     return NULL;
 }
 
-static int open_return_path_on_source(MigrationState *ms)
+static void open_return_path_on_source(MigrationState *ms)
 {
     ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
-    if (!ms->rp_state.from_dst_file) {
-        return -1;
-    }
 
     trace_open_return_path_on_source();
 
@@ -2660,8 +2657,6 @@ static int open_return_path_on_source(MigrationState *ms)
     ms->rp_state.rp_thread_created = true;
 
     trace_open_return_path_on_source_continue();
-
-    return 0;
 }
 
 /* Return true if error detected, or false otherwise */
@@ -4010,10 +4005,7 @@ void migration_connect(MigrationState *s, Error *error_in)
      * QEMU uses the return path.
      */
     if (migrate_postcopy_ram() || migrate_return_path()) {
-        if (open_return_path_on_source(s)) {
-            error_setg(&local_err, "Unable to open return-path for postcopy");
-            goto fail;
-        }
+        open_return_path_on_source(s);
     }
 
     /*
diff --git a/migration/qemu-file.c b/migration/qemu-file.c
index b6ac190034f777dbde0da1598483a892089d7538..f9ccee9a1091ecbd37e6b7d2081a4446442b544d 100644
--- a/migration/qemu-file.c
+++ b/migration/qemu-file.c
@@ -125,7 +125,6 @@ static QEMUFile *qemu_file_new_impl(QIOChannel *ioc, bool is_writable)
 
 /*
  * Result: QEMUFile* for a 'return path' for comms in the opposite direction
- *         NULL if not available
  */
 QEMUFile *qemu_file_get_return_path(QEMUFile *f)
 {
diff --git a/migration/savevm.c b/migration/savevm.c
index 21899e6beee3d2661c9a694379039e82cefbee4f..d8f5f1966fda831899596173f20fbef25d78829d 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2583,10 +2583,6 @@ static int loadvm_process_command(QEMUFile *f)
             return 0;
         }
         mis->to_src_file = qemu_file_get_return_path(f);
-        if (!mis->to_src_file) {
-            error_report("CMD_OPEN_RETURN_PATH failed");
-            return -1;
-        }
 
         /*
          * Switchover ack is enabled but no device uses it, so send an ACK to

-- 
2.50.0

[PATCH v7 08/24] migration: make loadvm_postcopy_handle_resume() void

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index d8f5f1966fda831899596173f20fbef25d78829d..ad96da3651b89023e4b70ffeecab46d176bae6f5 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2334,12 +2334,12 @@ static void migrate_send_rp_req_pages_pending(MigrationIncomingState *mis)
     }
 }
 
-static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
+static void loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
 {
     if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
-        error_report("%s: illegal resume received", __func__);
+        warn_report("%s: illegal resume received", __func__);
         /* Don't fail the load, only for this. */
-        return 0;
+        return;
     }
 
     /*
@@ -2391,8 +2391,6 @@ static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
         /* Kick the fast ram load thread too */
         qemu_sem_post(&mis->postcopy_pause_sem_fast_load);
     }
-
-    return 0;
 }
 
 /**
@@ -2627,7 +2625,8 @@ static int loadvm_process_command(QEMUFile *f)
         return loadvm_postcopy_ram_handle_discard(mis, len);
 
     case MIG_CMD_POSTCOPY_RESUME:
-        return loadvm_postcopy_handle_resume(mis);
+        loadvm_postcopy_handle_resume(mis);
+        return 0;
 
     case MIG_CMD_RECV_BITMAP:
         return loadvm_handle_recv_bitmap(mis, len);

-- 
2.50.0

[PATCH v7 09/24] migration: push Error **errp into loadvm_process_command()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_process_command() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 73 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 53 insertions(+), 20 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index ad96da3651b89023e4b70ffeecab46d176bae6f5..d40b25d74be46b209be8f28d10b7538a5ff2e3dd 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2544,12 +2544,13 @@ static int loadvm_postcopy_handle_switchover_start(void)
  * LOADVM_QUIT All good, but exit the loop
  * <0          Error
  */
-static int loadvm_process_command(QEMUFile *f)
+static int loadvm_process_command(QEMUFile *f, Error **errp)
 {
     MigrationIncomingState *mis = migration_incoming_get_current();
     uint16_t cmd;
     uint16_t len;
     uint32_t tmp32;
+    int ret;
 
     cmd = qemu_get_be16(f);
     len = qemu_get_be16(f);
@@ -2560,16 +2561,16 @@ static int loadvm_process_command(QEMUFile *f)
     }
 
     if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
-        error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
+        error_setg(errp, "MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
         return -EINVAL;
     }
 
     trace_loadvm_process_command(mig_cmd_args[cmd].name, len);
 
     if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
-        error_report("%s received with bad length - expecting %zu, got %d",
-                     mig_cmd_args[cmd].name,
-                     (size_t)mig_cmd_args[cmd].len, len);
+        error_setg(errp, "%s received with bad length - expecting %zu, got %d",
+                   mig_cmd_args[cmd].name,
+                   (size_t)mig_cmd_args[cmd].len, len);
         return -ERANGE;
     }
 
@@ -2588,11 +2589,11 @@ static int loadvm_process_command(QEMUFile *f)
          * been created.
          */
         if (migrate_switchover_ack() && !mis->switchover_ack_pending_num) {
-            int ret = migrate_send_rp_switchover_ack(mis);
+            ret = migrate_send_rp_switchover_ack(mis);
             if (ret) {
-                error_report(
-                    "Could not send switchover ack RP MSG, err %d (%s)", ret,
-                    strerror(-ret));
+                error_setg(errp,
+                           "Could not send switchover ack RP MSG, err %d (%s)",
+                           ret, strerror(-ret));
                 return ret;
             }
         }
@@ -2602,40 +2603,72 @@ static int loadvm_process_command(QEMUFile *f)
         tmp32 = qemu_get_be32(f);
         trace_loadvm_process_command_ping(tmp32);
         if (!mis->to_src_file) {
-            error_report("CMD_PING (0x%x) received with no return path",
-                         tmp32);
+            error_setg(errp, "CMD_PING (0x%x) received with no return path",
+                       tmp32);
             return -1;
         }
         migrate_send_rp_pong(mis, tmp32);
         break;
 
     case MIG_CMD_PACKAGED:
-        return loadvm_handle_cmd_packaged(mis);
+        ret = loadvm_handle_cmd_packaged(mis);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_POSTCOPY_ADVISE:
-        return loadvm_postcopy_handle_advise(mis, len);
+        ret = loadvm_postcopy_handle_advise(mis, len);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_POSTCOPY_LISTEN:
-        return loadvm_postcopy_handle_listen(mis);
+        ret = loadvm_postcopy_handle_listen(mis);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_POSTCOPY_RUN:
-        return loadvm_postcopy_handle_run(mis);
+        ret = loadvm_postcopy_handle_run(mis);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_POSTCOPY_RAM_DISCARD:
-        return loadvm_postcopy_ram_handle_discard(mis, len);
+        ret = loadvm_postcopy_ram_handle_discard(mis, len);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_POSTCOPY_RESUME:
         loadvm_postcopy_handle_resume(mis);
         return 0;
 
     case MIG_CMD_RECV_BITMAP:
-        return loadvm_handle_recv_bitmap(mis, len);
+        ret = loadvm_handle_recv_bitmap(mis, len);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_ENABLE_COLO:
-        return loadvm_process_enable_colo(mis);
+        ret = loadvm_process_enable_colo(mis);
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
 
     case MIG_CMD_SWITCHOVER_START:
-        return loadvm_postcopy_handle_switchover_start();
+        ret = loadvm_postcopy_handle_switchover_start();
+        if (ret < 0) {
+            error_setg(errp, "Failed to load device state command: %d", ret);
+        }
+        return ret;
     }
 
     return 0;
@@ -3075,7 +3108,7 @@ retry:
             }
             break;
         case QEMU_VM_COMMAND:
-            ret = loadvm_process_command(f);
+            ret = loadvm_process_command(f, NULL);
             trace_qemu_loadvm_state_section_command(ret);
             if ((ret < 0) || (ret == LOADVM_QUIT)) {
                 goto out;

-- 
2.50.0

[PATCH v7 10/24] migration: push Error **errp into loadvm_handle_cmd_packaged()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_handle_cmd_packaged() must report an error
in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index d40b25d74be46b209be8f28d10b7538a5ff2e3dd..63cf488d9f411c0fb8d5f1bc8a719aa575bbabdc 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2403,7 +2403,7 @@ static void loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
  * Returns: Negative values on error
  *
  */
-static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
+static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis, Error **errp)
 {
     int ret;
     size_t length;
@@ -2413,7 +2413,7 @@ static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
     trace_loadvm_handle_cmd_packaged(length);
 
     if (length > MAX_VM_CMD_PACKAGED_SIZE) {
-        error_report("Unreasonably large packaged state: %zu", length);
+        error_setg(errp, "Unreasonably large packaged state: %zu", length);
         return -1;
     }
 
@@ -2424,8 +2424,8 @@ static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
                           length);
     if (ret != length) {
         object_unref(OBJECT(bioc));
-        error_report("CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
-                     ret, length);
+        error_setg(errp, "CMD_PACKAGED: Buffer receive fail ret=%d length=%zu",
+                   ret, length);
         return (ret < 0) ? ret : -EAGAIN;
     }
     bioc->usage += length;
@@ -2455,6 +2455,9 @@ static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis)
     } while (1);
 
     ret = qemu_loadvm_state_main(packf, mis);
+    if (ret < 0) {
+        error_setg(errp, "VM state load failed: %d", ret);
+    }
     trace_loadvm_handle_cmd_packaged_main(ret);
     qemu_fclose(packf);
     object_unref(OBJECT(bioc));
@@ -2611,11 +2614,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         break;
 
     case MIG_CMD_PACKAGED:
-        ret = loadvm_handle_cmd_packaged(mis);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_handle_cmd_packaged(mis, errp);
 
     case MIG_CMD_POSTCOPY_ADVISE:
         ret = loadvm_postcopy_handle_advise(mis, len);

-- 
2.50.0

[PATCH v7 11/24] migration: push Error **errp into ram_postcopy_incoming_init()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that ram_postcopy_incoming_init() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/postcopy-ram.c | 9 ++++++---
 migration/postcopy-ram.h | 2 +-
 migration/ram.c          | 4 ++--
 migration/ram.h          | 2 +-
 migration/savevm.c       | 2 +-
 5 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/migration/postcopy-ram.c b/migration/postcopy-ram.c
index 45af9a361e8eacaad0fb217a5da2c5004416c1da..05617e5fbcad62226a54fe17d9f7d9a316baf1e4 100644
--- a/migration/postcopy-ram.c
+++ b/migration/postcopy-ram.c
@@ -681,6 +681,7 @@ out:
  */
 static int init_range(RAMBlock *rb, void *opaque)
 {
+    Error **errp = opaque;
     const char *block_name = qemu_ram_get_idstr(rb);
     void *host_addr = qemu_ram_get_host_addr(rb);
     ram_addr_t offset = qemu_ram_get_offset(rb);
@@ -701,6 +702,8 @@ static int init_range(RAMBlock *rb, void *opaque)
      * (Precopy will just overwrite this data, so doesn't need the discard)
      */
     if (ram_discard_range(block_name, 0, length)) {
+        error_setg(errp, "failed to discard RAM block %s len=%zu",
+                   block_name, length);
         return -1;
     }
 
@@ -749,9 +752,9 @@ static int cleanup_range(RAMBlock *rb, void *opaque)
  * postcopy later; must be called prior to any precopy.
  * called from arch_init's similarly named ram_postcopy_incoming_init
  */
-int postcopy_ram_incoming_init(MigrationIncomingState *mis)
+int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp)
 {
-    if (foreach_not_ignored_block(init_range, NULL)) {
+    if (foreach_not_ignored_block(init_range, errp)) {
         return -1;
     }
 
@@ -1703,7 +1706,7 @@ bool postcopy_ram_supported_by_host(MigrationIncomingState *mis, Error **errp)
     return false;
 }
 
-int postcopy_ram_incoming_init(MigrationIncomingState *mis)
+int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp)
 {
     error_report("postcopy_ram_incoming_init: No OS support");
     return -1;
diff --git a/migration/postcopy-ram.h b/migration/postcopy-ram.h
index 3852141d7e37ab18bada4b46c137fef0969d0070..ca19433b246893fa5105bcebffb442c58a9a4f48 100644
--- a/migration/postcopy-ram.h
+++ b/migration/postcopy-ram.h
@@ -30,7 +30,7 @@ int postcopy_ram_incoming_setup(MigrationIncomingState *mis);
  * postcopy later; must be called prior to any precopy.
  * called from ram.c's similarly named ram_postcopy_incoming_init
  */
-int postcopy_ram_incoming_init(MigrationIncomingState *mis);
+int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp);
 
 /*
  * At the end of a migration where postcopy_ram_incoming_init was called.
diff --git a/migration/ram.c b/migration/ram.c
index 7208bc114fb5c366740db380ee6956a91b3871a0..6a0dcc04f436524a37672c41c38f201f06773374 100644
--- a/migration/ram.c
+++ b/migration/ram.c
@@ -3716,9 +3716,9 @@ static int ram_load_cleanup(void *opaque)
  * postcopy-ram. postcopy-ram's similarly names
  * postcopy_ram_incoming_init does the work.
  */
-int ram_postcopy_incoming_init(MigrationIncomingState *mis)
+int ram_postcopy_incoming_init(MigrationIncomingState *mis, Error **errp)
 {
-    return postcopy_ram_incoming_init(mis);
+    return postcopy_ram_incoming_init(mis, errp);
 }
 
 /**
diff --git a/migration/ram.h b/migration/ram.h
index 921c39a2c5c45bc2344be80854c46e4c10c09aeb..275709a99187f9429ccb4111e05281ec268ba0db 100644
--- a/migration/ram.h
+++ b/migration/ram.h
@@ -86,7 +86,7 @@ void ram_postcopy_migrated_memory_release(MigrationState *ms);
 void ram_postcopy_send_discard_bitmap(MigrationState *ms);
 /* For incoming postcopy discard */
 int ram_discard_range(const char *block_name, uint64_t start, size_t length);
-int ram_postcopy_incoming_init(MigrationIncomingState *mis);
+int ram_postcopy_incoming_init(MigrationIncomingState *mis, Error **errp);
 int ram_load_postcopy(QEMUFile *f, int channel);
 
 void ram_handle_zero(void *host, uint64_t size);
diff --git a/migration/savevm.c b/migration/savevm.c
index 63cf488d9f411c0fb8d5f1bc8a719aa575bbabdc..60a055f3e1f248b09e5e5d721f14d2eeafd0a7ad 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -1989,7 +1989,7 @@ static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
         return -1;
     }
 
-    if (ram_postcopy_incoming_init(mis)) {
+    if (ram_postcopy_incoming_init(mis, NULL) < 0) {
         return -1;
     }
 

-- 
2.50.0

[PATCH v7 12/24] migration: push Error **errp into loadvm_postcopy_handle_advise()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_postcopy_handle_advise() must report an error
in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 40 +++++++++++++++++++---------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 60a055f3e1f248b09e5e5d721f14d2eeafd0a7ad..eb843f4869f7b49a17fe0fb1b0e36db993e4024e 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -1912,39 +1912,39 @@ enum LoadVMExitCodes {
  * quickly.
  */
 static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
-                                         uint16_t len)
+                                         uint16_t len, Error **errp)
 {
     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
     uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
     size_t page_size = qemu_target_page_size();
-    Error *local_err = NULL;
 
     trace_loadvm_postcopy_handle_advise();
     if (ps != POSTCOPY_INCOMING_NONE) {
-        error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)", ps);
+        error_setg(errp, "CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)",
+                   ps);
         return -1;
     }
 
     switch (len) {
     case 0:
         if (migrate_postcopy_ram()) {
-            error_report("RAM postcopy is enabled but have 0 byte advise");
+            error_setg(errp, "RAM postcopy is enabled but have 0 byte advise");
             return -EINVAL;
         }
         return 0;
     case 8 + 8:
         if (!migrate_postcopy_ram()) {
-            error_report("RAM postcopy is disabled but have 16 byte advise");
+            error_setg(errp,
+                       "RAM postcopy is disabled but have 16 byte advise");
             return -EINVAL;
         }
         break;
     default:
-        error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
+        error_setg(errp, "CMD_POSTCOPY_ADVISE invalid length (%d)", len);
         return -EINVAL;
     }
 
-    if (!postcopy_ram_supported_by_host(mis, &local_err)) {
-        error_report_err(local_err);
+    if (!postcopy_ram_supported_by_host(mis, errp)) {
         postcopy_state_set(POSTCOPY_INCOMING_NONE);
         return -1;
     }
@@ -1967,9 +1967,10 @@ static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
          *      also fails when passed to an older qemu that doesn't
          *      do huge pages.
          */
-        error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
-                                                             " d=%" PRIx64 ")",
-                     remote_pagesize_summary, local_pagesize_summary);
+        error_setg(errp,
+                   "Postcopy needs matching RAM page sizes "
+                   "(s=%" PRIx64 " d=%" PRIx64 ")",
+                   remote_pagesize_summary, local_pagesize_summary);
         return -1;
     }
 
@@ -1979,17 +1980,18 @@ static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
          * Again, some differences could be dealt with, but for now keep it
          * simple.
          */
-        error_report("Postcopy needs matching target page sizes (s=%d d=%zd)",
-                     (int)remote_tps, page_size);
+        error_setg(errp,
+                   "Postcopy needs matching target page sizes (s=%d d=%zd)",
+                   (int)remote_tps, page_size);
         return -1;
     }
 
-    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) {
-        error_report_err(local_err);
+    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, errp)) {
         return -1;
     }
 
-    if (ram_postcopy_incoming_init(mis, NULL) < 0) {
+    if (ram_postcopy_incoming_init(mis, errp) < 0) {
+        error_prepend(errp, "Postcopy RAM incoming init failed: ");
         return -1;
     }
 
@@ -2617,11 +2619,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_handle_cmd_packaged(mis, errp);
 
     case MIG_CMD_POSTCOPY_ADVISE:
-        ret = loadvm_postcopy_handle_advise(mis, len);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_postcopy_handle_advise(mis, len, errp);
 
     case MIG_CMD_POSTCOPY_LISTEN:
         ret = loadvm_postcopy_handle_listen(mis);

-- 
2.50.0

[PATCH v7 13/24] migration: push Error **errp into loadvm_postcopy_handle_listen()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_postcopy_handle_listen() must report an error
in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index eb843f4869f7b49a17fe0fb1b0e36db993e4024e..5a7564f60d8a465f136d1fab50e887630e276871 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2181,15 +2181,16 @@ static void *postcopy_ram_listen_thread(void *opaque)
 }
 
 /* After this message we must be able to immediately receive postcopy data */
-static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
+static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis,
+                                         Error **errp)
 {
     PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_LISTENING);
-    Error *local_err = NULL;
 
     trace_loadvm_postcopy_handle_listen("enter");
 
     if (ps != POSTCOPY_INCOMING_ADVISE && ps != POSTCOPY_INCOMING_DISCARD) {
-        error_report("CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
+        error_setg(errp,
+                   "CMD_POSTCOPY_LISTEN in wrong postcopy state (%d)", ps);
         return -1;
     }
     if (ps == POSTCOPY_INCOMING_ADVISE) {
@@ -2212,14 +2213,14 @@ static int loadvm_postcopy_handle_listen(MigrationIncomingState *mis)
     if (migrate_postcopy_ram()) {
         if (postcopy_ram_incoming_setup(mis)) {
             postcopy_ram_incoming_cleanup(mis);
+            error_setg(errp, "Failed to setup incoming postcopy RAM blocks");
             return -1;
         }
     }
 
     trace_loadvm_postcopy_handle_listen("after uffd");
 
-    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, &local_err)) {
-        error_report_err(local_err);
+    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_LISTEN, errp)) {
         return -1;
     }
 
@@ -2622,11 +2623,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_postcopy_handle_advise(mis, len, errp);
 
     case MIG_CMD_POSTCOPY_LISTEN:
-        ret = loadvm_postcopy_handle_listen(mis);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_postcopy_handle_listen(mis, errp);
 
     case MIG_CMD_POSTCOPY_RUN:
         ret = loadvm_postcopy_handle_run(mis);

-- 
2.50.0

[PATCH v7 14/24] migration: push Error **errp into loadvm_postcopy_handle_run()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_postcopy_handle_run() must report an error
in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 5a7564f60d8a465f136d1fab50e887630e276871..3a1d218901472ff2d3de8a9a26b80fa8453c27de 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2273,13 +2273,13 @@ static void loadvm_postcopy_handle_run_bh(void *opaque)
 }
 
 /* After all discards we can start running and asking for pages */
-static int loadvm_postcopy_handle_run(MigrationIncomingState *mis)
+static int loadvm_postcopy_handle_run(MigrationIncomingState *mis, Error **errp)
 {
     PostcopyState ps = postcopy_state_get();
 
     trace_loadvm_postcopy_handle_run();
     if (ps != POSTCOPY_INCOMING_LISTENING) {
-        error_report("CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
+        error_setg(errp, "CMD_POSTCOPY_RUN in wrong postcopy state (%d)", ps);
         return -1;
     }
 
@@ -2626,11 +2626,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_postcopy_handle_listen(mis, errp);
 
     case MIG_CMD_POSTCOPY_RUN:
-        ret = loadvm_postcopy_handle_run(mis);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_postcopy_handle_run(mis, errp);
 
     case MIG_CMD_POSTCOPY_RAM_DISCARD:
         ret = loadvm_postcopy_ram_handle_discard(mis, len);

-- 
2.50.0

[PATCH v7 15/24] migration: push Error **errp into loadvm_postcopy_ram_handle_discard()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_postcopy_ram_handle_discard() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 3a1d218901472ff2d3de8a9a26b80fa8453c27de..7ecaea90d245627c19722a234b78bc1383368bfd 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2004,7 +2004,7 @@ static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
  * There can be 0..many of these messages, each encoding multiple pages.
  */
 static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
-                                              uint16_t len)
+                                              uint16_t len, Error **errp)
 {
     int tmp;
     char ramid[256];
@@ -2017,6 +2017,7 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
         /* 1st discard */
         tmp = postcopy_ram_prepare_discard(mis);
         if (tmp) {
+            error_setg(errp, "Failed to prepare for RAM discard: %d", tmp);
             return tmp;
         }
         break;
@@ -2026,8 +2027,9 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
         break;
 
     default:
-        error_report("CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
-                     ps);
+        error_setg(errp,
+                   "CMD_POSTCOPY_RAM_DISCARD in wrong postcopy state (%d)",
+                   ps);
         return -1;
     }
     /* We're expecting a
@@ -2036,29 +2038,30 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
      *    then at least 1 16 byte chunk
     */
     if (len < (1 + 1 + 1 + 1 + 2 * 8)) {
-        error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
+        error_setg(errp, "CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
         return -1;
     }
 
     tmp = qemu_get_byte(mis->from_src_file);
     if (tmp != postcopy_ram_discard_version) {
-        error_report("CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
+        error_setg(errp, "CMD_POSTCOPY_RAM_DISCARD invalid version (%d)", tmp);
         return -1;
     }
 
     if (!qemu_get_counted_string(mis->from_src_file, ramid)) {
-        error_report("CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
+        error_setg(errp,
+                   "CMD_POSTCOPY_RAM_DISCARD Failed to read RAMBlock ID");
         return -1;
     }
     tmp = qemu_get_byte(mis->from_src_file);
     if (tmp != 0) {
-        error_report("CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
+        error_setg(errp, "CMD_POSTCOPY_RAM_DISCARD missing nil (%d)", tmp);
         return -1;
     }
 
     len -= 3 + strlen(ramid);
     if (len % 16) {
-        error_report("CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
+        error_setg(errp, "CMD_POSTCOPY_RAM_DISCARD invalid length (%d)", len);
         return -1;
     }
     trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
@@ -2070,6 +2073,7 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
         len -= 16;
         int ret = ram_discard_range(ramid, start_addr, block_length);
         if (ret) {
+            error_setg(errp, "Failed to discard RAM range %s: %d", ramid, ret);
             return ret;
         }
     }
@@ -2629,11 +2633,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_postcopy_handle_run(mis, errp);
 
     case MIG_CMD_POSTCOPY_RAM_DISCARD:
-        ret = loadvm_postcopy_ram_handle_discard(mis, len);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_postcopy_ram_handle_discard(mis, len, errp);
 
     case MIG_CMD_POSTCOPY_RESUME:
         loadvm_postcopy_handle_resume(mis);

-- 
2.50.0

[PATCH v7 16/24] migration: push Error **errp into loadvm_handle_recv_bitmap()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_handle_recv_bitmap() must report an error
in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index 7ecaea90d245627c19722a234b78bc1383368bfd..68e62163f70e1c2abcff74b3a2f7a5d2ed546b22 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2479,32 +2479,35 @@ static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis, Error **errp)
  * len (1 byte) + ramblock_name (<255 bytes)
  */
 static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,
-                                     uint16_t len)
+                                     uint16_t len, Error **errp)
 {
     QEMUFile *file = mis->from_src_file;
     RAMBlock *rb;
     char block_name[256];
     size_t cnt;
+    int ret;
 
     cnt = qemu_get_counted_string(file, block_name);
     if (!cnt) {
-        error_report("%s: failed to read block name", __func__);
+        error_setg(errp, "failed to read block name: %s", block_name);
         return -EINVAL;
     }
 
     /* Validate before using the data */
-    if (qemu_file_get_error(file)) {
-        return qemu_file_get_error(file);
+    ret = qemu_file_get_error(file);
+    if (ret < 0) {
+        error_setg(errp, "migration stream has error: %d", ret);
+        return ret;
     }
 
     if (len != cnt + 1) {
-        error_report("%s: invalid payload length (%d)", __func__, len);
+        error_setg(errp, "invalid payload length (%d)", len);
         return -EINVAL;
     }
 
     rb = qemu_ram_block_by_name(block_name);
     if (!rb) {
-        error_report("%s: block '%s' not found", __func__, block_name);
+        error_setg(errp, "block '%s' not found", block_name);
         return -EINVAL;
     }
 
@@ -2640,11 +2643,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return 0;
 
     case MIG_CMD_RECV_BITMAP:
-        ret = loadvm_handle_recv_bitmap(mis, len);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_handle_recv_bitmap(mis, len, errp);
 
     case MIG_CMD_ENABLE_COLO:
         ret = loadvm_process_enable_colo(mis);

-- 
2.50.0

[PATCH v7 17/24] migration: push Error **errp into loadvm_process_enable_colo()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that loadvm_process_enable_colo() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 include/migration/colo.h |  2 +-
 migration/migration.c    | 12 ++++++------
 migration/ram.c          |  8 ++++----
 migration/ram.h          |  2 +-
 migration/savevm.c       | 25 +++++++++++++------------
 5 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/include/migration/colo.h b/include/migration/colo.h
index 43222ef5ae6adc3f7d8aa6a48bef79af33d09208..d4fe422e4d335d3bef4f860f56400fcd73287a0e 100644
--- a/include/migration/colo.h
+++ b/include/migration/colo.h
@@ -25,7 +25,7 @@ void migrate_start_colo_process(MigrationState *s);
 bool migration_in_colo_state(void);
 
 /* loadvm */
-int migration_incoming_enable_colo(void);
+int migration_incoming_enable_colo(Error **errp);
 void migration_incoming_disable_colo(void);
 bool migration_incoming_colo_enabled(void);
 bool migration_incoming_in_colo_state(void);
diff --git a/migration/migration.c b/migration/migration.c
index b3bccaeaee806abd01595863f6475057049b0688..d748a02712dc4ebc2de6b0488fb199c92c4d4079 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -623,22 +623,22 @@ void migration_incoming_disable_colo(void)
     migration_colo_enabled = false;
 }
 
-int migration_incoming_enable_colo(void)
+int migration_incoming_enable_colo(Error **errp)
 {
 #ifndef CONFIG_REPLICATION
-    error_report("ENABLE_COLO command come in migration stream, but the "
-                 "replication module is not built in");
+    error_setg(errp, "ENABLE_COLO command come in migration stream, but the "
+               "replication module is not built in");
     return -ENOTSUP;
 #endif
 
     if (!migrate_colo()) {
-        error_report("ENABLE_COLO command come in migration stream, but x-colo "
-                     "capability is not set");
+        error_setg(errp, "ENABLE_COLO command come in migration stream"
+                   ", but x-colo capability is not set");
         return -EINVAL;
     }
 
     if (ram_block_discard_disable(true)) {
-        error_report("COLO: cannot disable RAM discard");
+        error_setg(errp, "COLO: cannot disable RAM discard");
         return -EBUSY;
     }
     migration_colo_enabled = true;
diff --git a/migration/ram.c b/migration/ram.c
index 6a0dcc04f436524a37672c41c38f201f06773374..995431c9e320f443c385c29d664d62e18c1afd90 100644
--- a/migration/ram.c
+++ b/migration/ram.c
@@ -3576,7 +3576,7 @@ static void colo_init_ram_state(void)
  * memory of the secondary VM, it is need to hold the global lock
  * to call this helper.
  */
-int colo_init_ram_cache(void)
+int colo_init_ram_cache(Error **errp)
 {
     RAMBlock *block;
 
@@ -3585,9 +3585,9 @@ int colo_init_ram_cache(void)
             block->colo_cache = qemu_anon_ram_alloc(block->used_length,
                                                     NULL, false, false);
             if (!block->colo_cache) {
-                error_report("%s: Can't alloc memory for COLO cache of block %s,"
-                             "size 0x" RAM_ADDR_FMT, __func__, block->idstr,
-                             block->used_length);
+                error_setg(errp, "Can't alloc memory for COLO cache of "
+                           "block %s, size 0x" RAM_ADDR_FMT,
+                           block->idstr, block->used_length);
                 RAMBLOCK_FOREACH_NOT_IGNORED(block) {
                     if (block->colo_cache) {
                         qemu_anon_ram_free(block->colo_cache, block->used_length);
diff --git a/migration/ram.h b/migration/ram.h
index 275709a99187f9429ccb4111e05281ec268ba0db..24cd0bf585762cfa1e86834dc03c6baeea2f0627 100644
--- a/migration/ram.h
+++ b/migration/ram.h
@@ -109,7 +109,7 @@ void ramblock_set_file_bmap_atomic(RAMBlock *block, ram_addr_t offset,
                                    bool set);
 
 /* ram cache */
-int colo_init_ram_cache(void);
+int colo_init_ram_cache(Error **errp);
 void colo_flush_ram_cache(void);
 void colo_release_ram_cache(void);
 void colo_incoming_start_dirty_log(void);
diff --git a/migration/savevm.c b/migration/savevm.c
index 68e62163f70e1c2abcff74b3a2f7a5d2ed546b22..e14e2156a4befec44eaaa992c8621a03e499ea76 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2518,15 +2518,20 @@ static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,
     return 0;
 }
 
-static int loadvm_process_enable_colo(MigrationIncomingState *mis)
+static int loadvm_process_enable_colo(MigrationIncomingState *mis,
+                                      Error **errp)
 {
-    int ret = migration_incoming_enable_colo();
+    int ret;
 
-    if (!ret) {
-        ret = colo_init_ram_cache();
-        if (ret) {
-            migration_incoming_disable_colo();
-        }
+    ret = migration_incoming_enable_colo(errp);
+    if (ret < 0) {
+        return ret;
+    }
+
+    ret = colo_init_ram_cache(errp);
+    if (ret) {
+        error_prepend(errp, "failed to init colo RAM cache: %d: ", ret);
+        migration_incoming_disable_colo();
     }
     return ret;
 }
@@ -2646,11 +2651,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_handle_recv_bitmap(mis, len, errp);
 
     case MIG_CMD_ENABLE_COLO:
-        ret = loadvm_process_enable_colo(mis);
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_process_enable_colo(mis, errp);
 
     case MIG_CMD_SWITCHOVER_START:
         ret = loadvm_postcopy_handle_switchover_start();

-- 
2.50.0

[PATCH v7 18/24] migration: push Error **errp into loadvm_postcopy_handle_switchover_start()

[Arun Menon]

This is an incremental step in converting vmstate loading code to report
error via Error objects instead of directly printing it to console/monitor.
It is ensured that loadvm_postcopy_handle_switchover_start() must report
an error in errp, in case of failure.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/savevm.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/migration/savevm.c b/migration/savevm.c
index e14e2156a4befec44eaaa992c8621a03e499ea76..6ac121a956f30ee2b1295a1e822395a99a3f6d36 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2536,7 +2536,7 @@ static int loadvm_process_enable_colo(MigrationIncomingState *mis,
     return ret;
 }
 
-static int loadvm_postcopy_handle_switchover_start(void)
+static int loadvm_postcopy_handle_switchover_start(Error **errp)
 {
     SaveStateEntry *se;
 
@@ -2549,6 +2549,7 @@ static int loadvm_postcopy_handle_switchover_start(void)
 
         ret = se->ops->switchover_start(se->opaque);
         if (ret < 0) {
+            error_setg(errp, "Switchover start failed: %d", ret);
             return ret;
         }
     }
@@ -2654,11 +2655,7 @@ static int loadvm_process_command(QEMUFile *f, Error **errp)
         return loadvm_process_enable_colo(mis, errp);
 
     case MIG_CMD_SWITCHOVER_START:
-        ret = loadvm_postcopy_handle_switchover_start();
-        if (ret < 0) {
-            error_setg(errp, "Failed to load device state command: %d", ret);
-        }
-        return ret;
+        return loadvm_postcopy_handle_switchover_start(errp);
     }
 
     return 0;

-- 
2.50.0

[PATCH v7 19/24] migration: push Error **errp into qemu_loadvm_state_main()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_loadvm_state_main() must report an error
in errp, in case of failure.
loadvm_process_command also sets the errp object explicitly.

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/colo.c   |  4 ++--
 migration/savevm.c | 25 ++++++++++++++-----------
 migration/savevm.h |  3 ++-
 3 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/migration/colo.c b/migration/colo.c
index 981bd4bf9ced8b45b4c5d494acae119a174ee974..5507dc25da24e0c6b030ac5563d663d70d013671 100644
--- a/migration/colo.c
+++ b/migration/colo.c
@@ -686,11 +686,11 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
 
     bql_lock();
     cpu_synchronize_all_states();
-    ret = qemu_loadvm_state_main(mis->from_src_file, mis);
+    ret = qemu_loadvm_state_main(mis->from_src_file, mis, errp);
     bql_unlock();
 
     if (ret < 0) {
-        error_setg(errp, "Load VM's live state (ram) error");
+        error_prepend(errp, "Load VM's live state (ram) error: ");
         return;
     }
 
diff --git a/migration/savevm.c b/migration/savevm.c
index 6ac121a956f30ee2b1295a1e822395a99a3f6d36..b125f31c1bd5c0d49e07247cb9ce46dfcea5b075 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2111,7 +2111,7 @@ static void *postcopy_ram_listen_thread(void *opaque)
     qemu_file_set_blocking(f, true);
 
     /* TODO: sanity check that only postcopiable data will be loaded here */
-    load_res = qemu_loadvm_state_main(f, mis);
+    load_res = qemu_loadvm_state_main(f, mis, NULL);
 
     /*
      * This is tricky, but, mis->from_src_file can change after it
@@ -2461,9 +2461,9 @@ static int loadvm_handle_cmd_packaged(MigrationIncomingState *mis, Error **errp)
         qemu_coroutine_yield();
     } while (1);
 
-    ret = qemu_loadvm_state_main(packf, mis);
+    ret = qemu_loadvm_state_main(packf, mis, errp);
     if (ret < 0) {
-        error_setg(errp, "VM state load failed: %d", ret);
+        error_prepend(errp, "Loading VM state failed: %d ", ret);
     }
     trace_loadvm_handle_cmd_packaged_main(ret);
     qemu_fclose(packf);
@@ -3064,7 +3064,8 @@ static bool postcopy_pause_incoming(MigrationIncomingState *mis)
     return true;
 }
 
-int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
+int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis,
+                           Error **errp)
 {
     uint8_t section_type;
     int ret = 0;
@@ -3073,8 +3074,10 @@ retry:
     while (true) {
         section_type = qemu_get_byte(f);
 
-        ret = qemu_file_get_error_obj_any(f, mis->postcopy_qemufile_dst, NULL);
+        ret = qemu_file_get_error_obj_any(f, mis->postcopy_qemufile_dst, errp);
         if (ret) {
+            error_prepend(errp, "Failed to load device state section ID: %d: ",
+                          ret);
             break;
         }
 
@@ -3082,20 +3085,20 @@ retry:
         switch (section_type) {
         case QEMU_VM_SECTION_START:
         case QEMU_VM_SECTION_FULL:
-            ret = qemu_loadvm_section_start_full(f, section_type, NULL);
+            ret = qemu_loadvm_section_start_full(f, section_type, errp);
             if (ret < 0) {
                 goto out;
             }
             break;
         case QEMU_VM_SECTION_PART:
         case QEMU_VM_SECTION_END:
-            ret = qemu_loadvm_section_part_end(f, section_type, NULL);
+            ret = qemu_loadvm_section_part_end(f, section_type, errp);
             if (ret < 0) {
                 goto out;
             }
             break;
         case QEMU_VM_COMMAND:
-            ret = loadvm_process_command(f, NULL);
+            ret = loadvm_process_command(f, errp);
             trace_qemu_loadvm_state_section_command(ret);
             if ((ret < 0) || (ret == LOADVM_QUIT)) {
                 goto out;
@@ -3105,7 +3108,7 @@ retry:
             /* This is the end of migration */
             goto out;
         default:
-            error_report("Unknown savevm section type %d", section_type);
+            error_setg(errp, "Unknown savevm section type %d", section_type);
             ret = -EINVAL;
             goto out;
         }
@@ -3169,7 +3172,7 @@ int qemu_loadvm_state(QEMUFile *f)
 
     cpu_synchronize_all_pre_loadvm();
 
-    ret = qemu_loadvm_state_main(f, mis);
+    ret = qemu_loadvm_state_main(f, mis, NULL);
     qemu_event_set(&mis->main_thread_load_event);
 
     trace_qemu_loadvm_state_post_main(ret);
@@ -3243,7 +3246,7 @@ int qemu_load_device_state(QEMUFile *f)
     int ret;
 
     /* Load QEMU_VM_SECTION_FULL section */
-    ret = qemu_loadvm_state_main(f, mis);
+    ret = qemu_loadvm_state_main(f, mis, NULL);
     if (ret < 0) {
         error_report("Failed to load device state: %d", ret);
         return ret;
diff --git a/migration/savevm.h b/migration/savevm.h
index 2d5e9c716686f06720325e82fe90c75335ced1de..fd7419e6ff90062970ed246b3ea71e6d49a6e372 100644
--- a/migration/savevm.h
+++ b/migration/savevm.h
@@ -66,7 +66,8 @@ int qemu_save_device_state(QEMUFile *f);
 
 int qemu_loadvm_state(QEMUFile *f);
 void qemu_loadvm_state_cleanup(MigrationIncomingState *mis);
-int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis);
+int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis,
+                           Error **errp);
 int qemu_load_device_state(QEMUFile *f);
 int qemu_loadvm_approve_switchover(void);
 int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f,

-- 
2.50.0

[PATCH v7 20/24] migration: push Error **errp into qemu_loadvm_state()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_loadvm_state() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/migration.c |  5 +++--
 migration/savevm.c    | 27 +++++++++++++++------------
 migration/savevm.h    |  2 +-
 3 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/migration/migration.c b/migration/migration.c
index d748a02712dc4ebc2de6b0488fb199c92c4d4079..0a5a8d5948b2b0a3f85163795e84f71903870d25 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -881,7 +881,7 @@ process_incoming_migration_co(void *opaque)
                       MIGRATION_STATUS_ACTIVE);
 
     mis->loadvm_co = qemu_coroutine_self();
-    ret = qemu_loadvm_state(mis->from_src_file);
+    ret = qemu_loadvm_state(mis->from_src_file, &local_err);
     mis->loadvm_co = NULL;
 
     trace_vmstate_downtime_checkpoint("dst-precopy-loadvm-completed");
@@ -908,7 +908,8 @@ process_incoming_migration_co(void *opaque)
     }
 
     if (ret < 0) {
-        error_setg(&local_err, "load of migration failed: %s", strerror(-ret));
+        error_prepend(&local_err, "load of migration failed: %s: ",
+                      strerror(-ret));
         goto fail;
     }
 
diff --git a/migration/savevm.c b/migration/savevm.c
index b125f31c1bd5c0d49e07247cb9ce46dfcea5b075..acdd32159bb303907af64b7970168112fcce2514 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -3142,27 +3142,24 @@ out:
     return ret;
 }
 
-int qemu_loadvm_state(QEMUFile *f)
+int qemu_loadvm_state(QEMUFile *f, Error **errp)
 {
     MigrationState *s = migrate_get_current();
     MigrationIncomingState *mis = migration_incoming_get_current();
-    Error *local_err = NULL;
     int ret;
 
-    if (qemu_savevm_state_blocked(&local_err)) {
-        error_report_err(local_err);
+    if (qemu_savevm_state_blocked(errp)) {
         return -EINVAL;
     }
 
     qemu_loadvm_thread_pool_create(mis);
 
-    ret = qemu_loadvm_state_header(f, NULL);
+    ret = qemu_loadvm_state_header(f, errp);
     if (ret) {
         return ret;
     }
 
-    if (qemu_loadvm_state_setup(f, &local_err) != 0) {
-        error_report_err(local_err);
+    if (qemu_loadvm_state_setup(f, errp) != 0) {
         return -EINVAL;
     }
 
@@ -3172,7 +3169,7 @@ int qemu_loadvm_state(QEMUFile *f)
 
     cpu_synchronize_all_pre_loadvm();
 
-    ret = qemu_loadvm_state_main(f, mis, NULL);
+    ret = qemu_loadvm_state_main(f, mis, errp);
     qemu_event_set(&mis->main_thread_load_event);
 
     trace_qemu_loadvm_state_post_main(ret);
@@ -3190,8 +3187,14 @@ int qemu_loadvm_state(QEMUFile *f)
         if (migrate_has_error(migrate_get_current()) ||
             !qemu_loadvm_thread_pool_wait(s, mis)) {
             ret = -EINVAL;
+            error_setg(errp,
+                       "Error while loading VM state: "
+                       "Migration stream has error");
         } else {
             ret = qemu_file_get_error(f);
+            if (ret < 0) {
+                error_setg(errp, "Error while loading vmstate : %d", ret);
+            }
         }
     }
     /*
@@ -3477,10 +3480,10 @@ void qmp_xen_load_devices_state(const char *filename, Error **errp)
     f = qemu_file_new_input(QIO_CHANNEL(ioc));
     object_unref(OBJECT(ioc));
 
-    ret = qemu_loadvm_state(f);
+    ret = qemu_loadvm_state(f, errp);
     qemu_fclose(f);
     if (ret < 0) {
-        error_setg(errp, "loading Xen device state failed");
+        error_prepend(errp, "loading Xen device state failed: ");
     }
     migration_incoming_state_destroy();
 }
@@ -3551,13 +3554,13 @@ bool load_snapshot(const char *name, const char *vmstate,
         ret = -EINVAL;
         goto err_drain;
     }
-    ret = qemu_loadvm_state(f);
+    ret = qemu_loadvm_state(f, errp);
     migration_incoming_state_destroy();
 
     bdrv_drain_all_end();
 
     if (ret < 0) {
-        error_setg(errp, "Error %d while loading VM state", ret);
+        error_prepend(errp, "Error %d while loading VM state: ", ret);
         return false;
     }
 
diff --git a/migration/savevm.h b/migration/savevm.h
index fd7419e6ff90062970ed246b3ea71e6d49a6e372..a6df5198f3fe1a39fc0e6ce3e79cf7a5d8e032db 100644
--- a/migration/savevm.h
+++ b/migration/savevm.h
@@ -64,7 +64,7 @@ void qemu_savevm_send_colo_enable(QEMUFile *f);
 void qemu_savevm_live_state(QEMUFile *f);
 int qemu_save_device_state(QEMUFile *f);
 
-int qemu_loadvm_state(QEMUFile *f);
+int qemu_loadvm_state(QEMUFile *f, Error **errp);
 void qemu_loadvm_state_cleanup(MigrationIncomingState *mis);
 int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis,
                            Error **errp);

-- 
2.50.0

[PATCH v7 21/24] migration: push Error **errp into qemu_load_device_state()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
It is ensured that qemu_load_device_state() must report an error
in errp, in case of failure.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/colo.c   | 4 ++--
 migration/savevm.c | 6 +++---
 migration/savevm.h | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/migration/colo.c b/migration/colo.c
index 5507dc25da24e0c6b030ac5563d663d70d013671..ec4ddc61d8ff7c4aebcd60a0d44286b0196adc34 100644
--- a/migration/colo.c
+++ b/migration/colo.c
@@ -729,9 +729,9 @@ static void colo_incoming_process_checkpoint(MigrationIncomingState *mis,
     bql_lock();
     vmstate_loading = true;
     colo_flush_ram_cache();
-    ret = qemu_load_device_state(fb);
+    ret = qemu_load_device_state(fb, errp);
     if (ret < 0) {
-        error_setg(errp, "COLO: load device state failed");
+        error_prepend(errp, "COLO: load device state failed: ");
         vmstate_loading = false;
         bql_unlock();
         return;
diff --git a/migration/savevm.c b/migration/savevm.c
index acdd32159bb303907af64b7970168112fcce2514..810bba9799246c8d57514be0927bb474edee8e9b 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -3243,15 +3243,15 @@ int qemu_loadvm_state(QEMUFile *f, Error **errp)
     return ret;
 }
 
-int qemu_load_device_state(QEMUFile *f)
+int qemu_load_device_state(QEMUFile *f, Error **errp)
 {
     MigrationIncomingState *mis = migration_incoming_get_current();
     int ret;
 
     /* Load QEMU_VM_SECTION_FULL section */
-    ret = qemu_loadvm_state_main(f, mis, NULL);
+    ret = qemu_loadvm_state_main(f, mis, errp);
     if (ret < 0) {
-        error_report("Failed to load device state: %d", ret);
+        error_prepend(errp, "Failed to load device state: %d: ", ret);
         return ret;
     }
 
diff --git a/migration/savevm.h b/migration/savevm.h
index a6df5198f3fe1a39fc0e6ce3e79cf7a5d8e032db..c337e3e3d111a7f28a57b90f61e8f70b71803d4e 100644
--- a/migration/savevm.h
+++ b/migration/savevm.h
@@ -68,7 +68,7 @@ int qemu_loadvm_state(QEMUFile *f, Error **errp);
 void qemu_loadvm_state_cleanup(MigrationIncomingState *mis);
 int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis,
                            Error **errp);
-int qemu_load_device_state(QEMUFile *f);
+int qemu_load_device_state(QEMUFile *f, Error **errp);
 int qemu_loadvm_approve_switchover(void);
 int qemu_savevm_state_complete_precopy_non_iterable(QEMUFile *f,
         bool in_postcopy);

-- 
2.50.0

[PATCH v7 22/24] migration: Capture error in postcopy_ram_listen_thread()

[Arun Menon]

This is an incremental step in converting vmstate loading
code to report error via Error objects instead of directly
printing it to console/monitor.
postcopy_ram_listen_thread() calls qemu_loadvm_state_main()
to load the vm, and in case of a failure, it should set the error
in the migration object.

When postcopy live migration runs, the device states are loaded by
both the qemu coroutine process_incoming_migration_co() and the
postcopy_ram_listen_thread(). Therefore, it is important that the
coroutine also reports the error in case of failure, with
error_report_err(). Otherwise, the source qemu will not display
any errors before going into the postcopy pause state.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 migration/migration.c |  2 +-
 migration/savevm.c    | 10 ++++++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/migration/migration.c b/migration/migration.c
index 0a5a8d5948b2b0a3f85163795e84f71903870d25..4a76d7ed730589bae87115368b0bf4819f8b161e 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -925,7 +925,7 @@ fail:
     migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
                       MIGRATION_STATUS_FAILED);
     migrate_set_error(s, local_err);
-    error_free(local_err);
+    error_report_err(local_err);
 
     migration_incoming_state_destroy();
 
diff --git a/migration/savevm.c b/migration/savevm.c
index 810bba9799246c8d57514be0927bb474edee8e9b..202bb9f494c9185434a50967c439ce84e0b3acee 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -2095,6 +2095,7 @@ static void *postcopy_ram_listen_thread(void *opaque)
     QEMUFile *f = mis->from_src_file;
     int load_res;
     MigrationState *migr = migrate_get_current();
+    Error *local_err = NULL;
 
     object_ref(OBJECT(migr));
 
@@ -2111,7 +2112,7 @@ static void *postcopy_ram_listen_thread(void *opaque)
     qemu_file_set_blocking(f, true);
 
     /* TODO: sanity check that only postcopiable data will be loaded here */
-    load_res = qemu_loadvm_state_main(f, mis, NULL);
+    load_res = qemu_loadvm_state_main(f, mis, &local_err);
 
     /*
      * This is tricky, but, mis->from_src_file can change after it
@@ -2137,7 +2138,12 @@ static void *postcopy_ram_listen_thread(void *opaque)
                          __func__, load_res);
             load_res = 0; /* prevent further exit() */
         } else {
-            error_report("%s: loadvm failed: %d", __func__, load_res);
+            if (local_err != NULL) {
+                error_prepend(&local_err,
+                              "loadvm failed during postcopy: %d: ", load_res);
+                migrate_set_error(migr, local_err);
+                error_report_err(local_err);
+            }
             migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
                                            MIGRATION_STATUS_FAILED);
         }

-- 
2.50.0

[PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Arun Menon]

- We need to have good error reporting in the callbacks in
  VMStateDescription struct. Specifically pre_save, post_save,
  pre_load and post_load callbacks.
- It is not possible to change these functions everywhere in one
  patch, therefore, we introduce a duplicate set of callbacks
  with Error object passed to them.
- So, in this commit, we implement 'errp' variants of these callbacks,
  introducing an explicit Error object parameter.
- This is a functional step towards transitioning the entire codebase
  to the new error-parameterized functions.
- Deliberately called in mutual exclusion from their counterparts,
  to prevent conflicts during the transition.
- New impls should preferentally use 'errp' variants of
  these methods, and existing impls incrementally converted.
  The variants without 'errp' are intended to be removed
  once all usage is converted.

Signed-off-by: Arun Menon <armenon@redhat.com>
---
 include/migration/vmstate.h | 11 ++++++++
 migration/vmstate.c         | 62 +++++++++++++++++++++++++++++++++++++++------
 2 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
index 056781b1c21e737583f081594d9f88b32adfd674..53fa72c1bbde399be02c88fc8745fdbb79bfd7c8 100644
--- a/include/migration/vmstate.h
+++ b/include/migration/vmstate.h
@@ -200,15 +200,26 @@ struct VMStateDescription {
      * exclusive. For this reason, also early_setup VMSDs are migrated in a
      * QEMU_VM_SECTION_FULL section, while save_setup() data is migrated in
      * a QEMU_VM_SECTION_START section.
+     *
+     * There are duplicate impls of the post/pre save/load hooks.
+     * New impls should preferentally use 'errp' variants of these
+     * methods and existing impls incrementally converted.
+     * The variants without 'errp' are intended to be removed
+     * once all usage is converted.
      */
+
     bool early_setup;
     int version_id;
     int minimum_version_id;
     MigrationPriority priority;
     int (*pre_load)(void *opaque);
+    int (*pre_load_errp)(void *opaque, Error **errp);
     int (*post_load)(void *opaque, int version_id);
+    int (*post_load_errp)(void *opaque, int version_id, Error **errp);
     int (*pre_save)(void *opaque);
+    int (*pre_save_errp)(void *opaque, Error **errp);
     int (*post_save)(void *opaque);
+    int (*post_save_errp)(void *opaque, Error **errp);
     bool (*needed)(void *opaque);
     bool (*dev_unplug_pending)(void *opaque);
 
diff --git a/migration/vmstate.c b/migration/vmstate.c
index bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb..e427ef49b2b1991b0a3cdb14d641c197e00014b0 100644
--- a/migration/vmstate.c
+++ b/migration/vmstate.c
@@ -152,7 +152,16 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
         trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
         return -EINVAL;
     }
-    if (vmsd->pre_load) {
+    if (vmsd->pre_load_errp) {
+        ret = vmsd->pre_load_errp(opaque, errp);
+        if (ret) {
+            error_prepend(errp, "VM pre load failed for: '%s', "
+                          "version_id: '%d', minimum version_id: '%d', "
+                          "ret: %d: ", vmsd->name, vmsd->version_id,
+                          vmsd->minimum_version_id, ret);
+            return ret;
+        }
+    } else if (vmsd->pre_load) {
         ret = vmsd->pre_load(opaque);
         if (ret) {
             error_setg(errp, "VM pre load failed for: '%s', "
@@ -236,7 +245,14 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
         qemu_file_set_error(f, ret);
         return ret;
     }
-    if (vmsd->post_load) {
+    if (vmsd->post_load_errp) {
+        ret = vmsd->post_load_errp(opaque, version_id, errp);
+        if (ret < 0) {
+            error_prepend(errp, "VM Post load failed for: %s, version_id: %d, "
+                          "minimum_version: %d, ret: %d: ", vmsd->name,
+                          vmsd->version_id, vmsd->minimum_version_id, ret);
+        }
+    } else if (vmsd->post_load) {
         ret = vmsd->post_load(opaque, version_id);
         if (ret < 0) {
             error_setg(errp,
@@ -412,11 +428,19 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
                          void *opaque, JSONWriter *vmdesc, int version_id, Error **errp)
 {
     int ret = 0;
+    Error *local_err = NULL;
     const VMStateField *field = vmsd->fields;
 
     trace_vmstate_save_state_top(vmsd->name);
 
-    if (vmsd->pre_save) {
+    if (vmsd->pre_save_errp) {
+        ret = vmsd->pre_save_errp(opaque, errp);
+        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
+        if (ret) {
+            error_prepend(errp, "pre-save failed: %s: ", vmsd->name);
+            return ret;
+        }
+    } else if (vmsd->pre_save) {
         ret = vmsd->pre_save(opaque);
         trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
         if (ret) {
@@ -524,10 +548,22 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
                 }
 
                 if (ret) {
-                    error_setg(errp, "Save of field %s/%s failed",
-                                vmsd->name, field->name);
-                    if (vmsd->post_save) {
-                        vmsd->post_save(opaque);
+                    if (*errp == NULL) {
+                        error_setg(errp, "Save of field %s/%s failed",
+                                   vmsd->name, field->name);
+                    }
+                    if (vmsd->post_save_errp) {
+                        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
+                        if (ps_ret < 0) {
+                            error_free_or_abort(errp);
+                            error_propagate(errp, local_err);
+                            ret = ps_ret;
+                        }
+                    } else if (vmsd->post_save) {
+                        int ps_ret = vmsd->post_save(opaque);
+                        if (ps_ret < 0) {
+                            ret = ps_ret;
+                        }
                     }
                     return ret;
                 }
@@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
 
     ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
 
-    if (vmsd->post_save) {
+    if (vmsd->post_save_errp) {
+        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
+        if (!ret && ps_ret) {
+            ret = ps_ret;
+            error_propagate(errp, local_err);
+        } else if (ret && ps_ret) {
+            error_free_or_abort(errp);
+            error_propagate(errp, local_err);
+            ret = ps_ret;
+        }
+    } else if (vmsd->post_save) {
         int ps_ret = vmsd->post_save(opaque);
         if (!ret && ps_ret) {
             ret = ps_ret;

-- 
2.50.0

[PATCH v7 24/24] backends/tpm: Propagate vTPM error on migration failure

[Arun Menon]

- When migration of a VM with encrypted vTPM fails on the
  destination host, (e.g., due to a mismatch in secret values),
  the error message displayed on the source host is generic and unhelpful.
- For example, a typical error looks like this:
  "operation failed: job 'migration out' failed: Sibling indicated error 1.
  operation failed: job 'migration in' failed: load of migration failed:
  Input/output error"
- Such generic errors are logged using error_report(), which prints to
  the console/monitor but does not make the detailed error accessible via
  the QMP query-migrate command.
- This change, along with the set of changes of passing errp Error object
  to the VM state loading functions, help in addressing the issue.
  We use the post_load_errp hook of VMStateDescription to propagate errors
  by setting Error **errp objects in case of failure in the TPM backend.
- It can then be retrieved using QMP command:
  {"execute" : "query-migrate"}

Buglink: https://issues.redhat.com/browse/RHEL-82826

Reviewed-by: Stefan Berger <stefanb@linux.ibm.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Arun Menon <armenon@redhat.com>
---
 backends/tpm/tpm_emulator.c | 39 ++++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/backends/tpm/tpm_emulator.c b/backends/tpm/tpm_emulator.c
index 4a234ab2c0b19b2604bf0dd8cb5f4540c72a9438..9bf5927e8e1542cf2e4f2275783d32853d5f1473 100644
--- a/backends/tpm/tpm_emulator.c
+++ b/backends/tpm/tpm_emulator.c
@@ -819,7 +819,8 @@ static int tpm_emulator_get_state_blobs(TPMEmulator *tpm_emu)
 static int tpm_emulator_set_state_blob(TPMEmulator *tpm_emu,
                                        uint32_t type,
                                        TPMSizedBuffer *tsb,
-                                       uint32_t flags)
+                                       uint32_t flags,
+                                       Error **errp)
 {
     ssize_t n;
     ptm_setstate pss;
@@ -838,17 +839,17 @@ static int tpm_emulator_set_state_blob(TPMEmulator *tpm_emu,
     /* write the header only */
     if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SET_STATEBLOB, &pss,
                              offsetof(ptm_setstate, u.req.data), 0, 0) < 0) {
-        error_report("tpm-emulator: could not set state blob type %d : %s",
-                     type, strerror(errno));
+        error_setg(errp, "tpm-emulator: could not set state blob type %d : %s",
+                   type, strerror(errno));
         return -1;
     }
 
     /* now the body */
     n = qemu_chr_fe_write_all(&tpm_emu->ctrl_chr, tsb->buffer, tsb->size);
     if (n != tsb->size) {
-        error_report("tpm-emulator: Writing the stateblob (type %d) "
-                     "failed; could not write %u bytes, but only %zd",
-                     type, tsb->size, n);
+        error_setg(errp, "tpm-emulator: Writing the stateblob (type %d) "
+                   "failed; could not write %u bytes, but only %zd",
+                   type, tsb->size, n);
         return -1;
     }
 
@@ -856,17 +857,17 @@ static int tpm_emulator_set_state_blob(TPMEmulator *tpm_emu,
     n = qemu_chr_fe_read_all(&tpm_emu->ctrl_chr,
                              (uint8_t *)&pss, sizeof(pss.u.resp));
     if (n != sizeof(pss.u.resp)) {
-        error_report("tpm-emulator: Reading response from writing stateblob "
-                     "(type %d) failed; expected %zu bytes, got %zd", type,
-                     sizeof(pss.u.resp), n);
+        error_setg(errp, "tpm-emulator: Reading response from writing "
+                   "stateblob (type %d) failed; expected %zu bytes, "
+                   "got %zd", type, sizeof(pss.u.resp), n);
         return -1;
     }
 
     tpm_result = be32_to_cpu(pss.u.resp.tpm_result);
     if (tpm_result != 0) {
-        error_report("tpm-emulator: Setting the stateblob (type %d) failed "
-                     "with a TPM error 0x%x %s", type, tpm_result,
-                     tpm_emulator_strerror(tpm_result));
+        error_setg(errp, "tpm-emulator: Setting the stateblob (type %d) "
+                   "failed with a TPM error 0x%x %s", type, tpm_result,
+                   tpm_emulator_strerror(tpm_result));
         return -1;
     }
 
@@ -880,7 +881,7 @@ static int tpm_emulator_set_state_blob(TPMEmulator *tpm_emu,
  *
  * Returns a negative errno code in case of error.
  */
-static int tpm_emulator_set_state_blobs(TPMBackend *tb)
+static int tpm_emulator_set_state_blobs(TPMBackend *tb, Error **errp)
 {
     TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
     TPMBlobBuffers *state_blobs = &tpm_emu->state_blobs;
@@ -894,13 +895,13 @@ static int tpm_emulator_set_state_blobs(TPMBackend *tb)
 
     if (tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_PERMANENT,
                                     &state_blobs->permanent,
-                                    state_blobs->permanent_flags) < 0 ||
+                                    state_blobs->permanent_flags, errp) < 0 ||
         tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_VOLATILE,
                                     &state_blobs->volatil,
-                                    state_blobs->volatil_flags) < 0 ||
+                                    state_blobs->volatil_flags, errp) < 0 ||
         tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_SAVESTATE,
                                     &state_blobs->savestate,
-                                    state_blobs->savestate_flags) < 0) {
+                                    state_blobs->savestate_flags, errp) < 0) {
         return -EIO;
     }
 
@@ -948,12 +949,12 @@ static void tpm_emulator_vm_state_change(void *opaque, bool running,
  *
  * Returns negative errno codes in case of error.
  */
-static int tpm_emulator_post_load(void *opaque, int version_id)
+static int tpm_emulator_post_load(void *opaque, int version_id, Error **errp)
 {
     TPMBackend *tb = opaque;
     int ret;
 
-    ret = tpm_emulator_set_state_blobs(tb);
+    ret = tpm_emulator_set_state_blobs(tb, errp);
     if (ret < 0) {
         return ret;
     }
@@ -969,7 +970,7 @@ static const VMStateDescription vmstate_tpm_emulator = {
     .name = "tpm-emulator",
     .version_id = 0,
     .pre_save = tpm_emulator_pre_save,
-    .post_load = tpm_emulator_post_load,
+    .post_load_errp = tpm_emulator_post_load,
     .fields = (const VMStateField[]) {
         VMSTATE_UINT32(state_blobs.permanent_flags, TPMEmulator),
         VMSTATE_UINT32(state_blobs.permanent.size, TPMEmulator),

-- 
2.50.0

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 3142 bytes --]

On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that vmstate_subsection_load() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
> ---
>  migration/vmstate.c | 11 ++++++++---
>  1 file changed, 8 insertions(+), 3 deletions(-)
>
> diff --git a/migration/vmstate.c b/migration/vmstate.c
> index
> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
> 100644
> --- a/migration/vmstate.c
> +++ b/migration/vmstate.c
> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
> VMStateDescription *vmsd,
>                                     void *opaque, JSONWriter *vmdesc,
>                                     Error **errp);
>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> *vmsd,
> -                                   void *opaque);
> +                                   void *opaque, Error **errp);
>
>  /* Whether this field should exist for either save or load the VM? */
>  static bool
> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
> VMStateDescription *vmsd,
>          field++;
>      }
>      assert(field->flags == VMS_END);
> -    ret = vmstate_subsection_load(f, vmsd, opaque);
> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
>      if (ret != 0) {
>          qemu_file_set_error(f, ret);
>          return ret;
> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
> const *sub,
>  }
>
>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> *vmsd,
> -                                   void *opaque)
> +                                   void *opaque, Error **errp)
>  {
>      trace_vmstate_subsection_load(vmsd->name);
>
> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
> VMStateDescription *vmsd,
>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
>          if (sub_vmsd == NULL) {
>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> "(lookup)");
> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
> +                       idstr, vmsd->name);
>              return -ENOENT;
>          }
>          qemu_file_skip(f, 1); /* subsection */
> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
> VMStateDescription *vmsd,
>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
>          if (ret) {
>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> "(child)");
> +            error_setg(errp,
> +                       "Loading VM subsection '%s' in '%s' failed : %d",
>

extra space before ":"

other than that
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> +                       idstr, vmsd->name, ret);
>              return ret;
>          }
>      }
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 4243 bytes --]

Re: [PATCH v7 02/24] migration: push Error **errp into vmstate_load_state()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 21423 bytes --]

On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that vmstate_load_state() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  hw/display/virtio-gpu.c     |  2 +-
>  hw/pci/pci.c                |  2 +-
>  hw/s390x/virtio-ccw.c       |  2 +-
>  hw/scsi/spapr_vscsi.c       |  2 +-
>  hw/vfio/pci.c               |  2 +-
>  hw/virtio/virtio-mmio.c     |  2 +-
>  hw/virtio/virtio-pci.c      |  2 +-
>  hw/virtio/virtio.c          |  4 ++--
>  include/migration/vmstate.h |  2 +-
>  migration/cpr.c             |  4 ++--
>  migration/savevm.c          |  6 ++++--
>  migration/vmstate-types.c   | 10 ++++-----
>  migration/vmstate.c         | 49
> ++++++++++++++++++++++++++++-----------------
>  tests/unit/test-vmstate.c   | 18 ++++++++---------
>  ui/vdagent.c                |  2 +-
>  15 files changed, 62 insertions(+), 47 deletions(-)
>
> diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c
> index
> 0a1a625b0ea6cf26cb0d799171a57ed3d3ab2442..5d2ca8d8b864350133a674802d7316abd379591c
> 100644
> --- a/hw/display/virtio-gpu.c
> +++ b/hw/display/virtio-gpu.c
> @@ -1343,7 +1343,7 @@ 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);
> +    vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, NULL);
>
>      return 0;
>  }
> diff --git a/hw/pci/pci.c b/hw/pci/pci.c
> index
> c70b5ceebaf1f2b10768bd030526cbb518da2b8d..2ab5d30bb3c319ac1c7bfc9a2acf6a2b38082066
> 100644
> --- a/hw/pci/pci.c
> +++ b/hw/pci/pci.c
> @@ -934,7 +934,7 @@ void pci_device_save(PCIDevice *s, QEMUFile *f)
>  int pci_device_load(PCIDevice *s, QEMUFile *f)
>  {
>      int ret;
> -    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id);
> +    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id,
> NULL);
>      /* Restore the interrupt status bit. */
>      pci_update_irq_status(s);
>      return ret;
> diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
> index
> d2f85b39f30f7fc82e0c600144c0a958e1269b2c..2f6feff2b0a22d7d7f6aecfd7e7870d8362f1a73
> 100644
> --- a/hw/s390x/virtio-ccw.c
> +++ b/hw/s390x/virtio-ccw.c
> @@ -1136,7 +1136,7 @@ static void virtio_ccw_save_config(DeviceState *d,
> QEMUFile *f)
>  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);
> +    return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, NULL);
>  }
>
>  static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
> diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c
> index
> 20f70fb2729de78b9636a6b8c869695dab4f8902..573fdea668536b464bca11f001e9e0288e781493
> 100644
> --- a/hw/scsi/spapr_vscsi.c
> +++ b/hw/scsi/spapr_vscsi.c
> @@ -648,7 +648,7 @@ static void *vscsi_load_request(QEMUFile *f,
> SCSIRequest *sreq)
>      assert(!req->active);
>
>      memset(req, 0, sizeof(*req));
> -    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1);
> +    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1, NULL);
>      if (rc) {
>          fprintf(stderr, "VSCSI: failed loading request tag#%u\n",
> sreq->tag);
>          return NULL;
> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> index
> e72d514a4cb91946f7c79332492bf5d709c308f2..498bbb96e97df50af5fc906fa00d4436c1edc05f
> 100644
> --- a/hw/vfio/pci.c
> +++ b/hw/vfio/pci.c
> @@ -2797,7 +2797,7 @@ static int vfio_pci_load_config(VFIODevice
> *vbasedev, QEMUFile *f)
>          old_addr[bar] = pdev->io_regions[bar].addr;
>      }
>
> -    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1);
> +    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1, NULL);
>      if (ret) {
>          return ret;
>      }
> diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c
> index
> 532c67107ba1d2978a76cf49f9cdc1de1dea3e11..9058b1563462d4464dcba799643a583c93fb5683
> 100644
> --- a/hw/virtio/virtio-mmio.c
> +++ b/hw/virtio/virtio-mmio.c
> @@ -619,7 +619,7 @@ static int virtio_mmio_load_extra_state(DeviceState
> *opaque, QEMUFile *f)
>  {
>      VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
>
> -    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1);
> +    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, NULL);
>  }
>
>  static bool virtio_mmio_has_extra_state(DeviceState *opaque)
> diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
> index
> 767216d795998708f5716a23ae16c79cd90ff489..f8b52a611e56c22d844fd4cae3619da4f2686d03
> 100644
> --- a/hw/virtio/virtio-pci.c
> +++ b/hw/virtio/virtio-pci.c
> @@ -161,7 +161,7 @@ static int virtio_pci_load_extra_state(DeviceState *d,
> QEMUFile *f)
>  {
>      VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
>
> -    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1);
> +    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, NULL);
>  }
>
>  static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
> diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
> index
> 2ab1d20769495ea39445b87e3673b076ad172510..d5698b062a1e95437f6113f41136e90ae06f1974
> 100644
> --- a/hw/virtio/virtio.c
> +++ b/hw/virtio/virtio.c
> @@ -3317,14 +3317,14 @@ virtio_load(VirtIODevice *vdev, QEMUFile *f, int
> version_id)
>      }
>
>      if (vdc->vmsd) {
> -        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id);
> +        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id, NULL);
>          if (ret) {
>              return ret;
>          }
>      }
>
>      /* Subsections */
> -    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
> +    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1, NULL);
>      if (ret) {
>          return ret;
>      }
> diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> index
> 1ff7bd9ac425ba67cd5ca7ad97bcf570f9e19abe..056781b1c21e737583f081594d9f88b32adfd674
> 100644
> --- a/include/migration/vmstate.h
> +++ b/include/migration/vmstate.h
> @@ -1196,7 +1196,7 @@ extern const VMStateInfo vmstate_info_qlist;
>      }
>
>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> -                       void *opaque, int version_id);
> +                       void *opaque, int version_id, Error **errp);
>  int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
>                         void *opaque, JSONWriter *vmdesc);
>  int vmstate_save_state_with_err(QEMUFile *f, const VMStateDescription
> *vmsd,
> diff --git a/migration/cpr.c b/migration/cpr.c
> index
> 42ad0b0d500e5de57faf0c6517e216b2d1c0cacf..9569c3f76bf8714def6406ae24f7fbc5afa4e793
> 100644
> --- a/migration/cpr.c
> +++ b/migration/cpr.c
> @@ -233,9 +233,9 @@ int cpr_state_load(MigrationChannel *channel, Error
> **errp)
>          return -ENOTSUP;
>      }
>
> -    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1);
> +    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1, errp);
>      if (ret) {
> -        error_setg(errp, "vmstate_load_state error %d", ret);
> +        error_prepend(errp, "vmstate_load_state error %d: ", ret);
>          qemu_fclose(f);
>          return ret;
>      }
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> fabbeb296ae987d0c06ba6dafda63720205fecfd..ab947620f724874f325fb9fb59bef50b7c16fb51
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -969,7 +969,8 @@ static int vmstate_load(QEMUFile *f, SaveStateEntry
> *se)
>      if (!se->vmsd) {         /* Old style */
>          return se->ops->load_state(f, se->opaque, se->load_version_id);
>      }
> -    return vmstate_load_state(f, se->vmsd, se->opaque,
> se->load_version_id);
> +    return vmstate_load_state(f, se->vmsd, se->opaque,
> se->load_version_id,
> +                              NULL);
>  }
>
>  static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
> @@ -2839,7 +2840,8 @@ static int qemu_loadvm_state_header(QEMUFile *f)
>              error_report("Configuration section missing");
>              return -EINVAL;
>          }
> -        ret = vmstate_load_state(f, &vmstate_configuration,
> &savevm_state, 0);
> +        ret = vmstate_load_state(f, &vmstate_configuration,
> &savevm_state, 0,
> +                                 NULL);
>
>          if (ret) {
>              return ret;
> diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c
> index
> 741a588b7e18c6d37724b08a0101edc8bc74a0a5..1c5b76e1dd198030847971bc35637867c9d54fc0
> 100644
> --- a/migration/vmstate-types.c
> +++ b/migration/vmstate-types.c
> @@ -549,7 +549,7 @@ static int get_tmp(QEMUFile *f, void *pv, size_t size,
>
>      /* Writes the parent field which is at the start of the tmp */
>      *(void **)tmp = pv;
> -    ret = vmstate_load_state(f, vmsd, tmp, version_id);
> +    ret = vmstate_load_state(f, vmsd, tmp, version_id, NULL);
>      g_free(tmp);
>      return ret;
>  }
> @@ -649,7 +649,7 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t
> unused_size,
>
>      while (qemu_get_byte(f)) {
>          elm = g_malloc(size);
> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
>          if (ret) {
>              return ret;
>          }
> @@ -803,7 +803,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
> unused_size,
>              key = (void *)(uintptr_t)qemu_get_be64(f);
>          } else {
>              key = g_malloc0(key_size);
> -            ret = vmstate_load_state(f, key_vmsd, key, version_id);
> +            ret = vmstate_load_state(f, key_vmsd, key, version_id, NULL);
>              if (ret) {
>                  error_report("%s : failed to load %s (%d)",
>                               field->name, key_vmsd->name, ret);
> @@ -811,7 +811,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
> unused_size,
>              }
>          }
>          val = g_malloc0(val_size);
> -        ret = vmstate_load_state(f, val_vmsd, val, version_id);
> +        ret = vmstate_load_state(f, val_vmsd, val, version_id, NULL);
>          if (ret) {
>              error_report("%s : failed to load %s (%d)",
>                           field->name, val_vmsd->name, ret);
> @@ -892,7 +892,7 @@ static int get_qlist(QEMUFile *f, void *pv, size_t
> unused_size,
>
>      while (qemu_get_byte(f)) {
>          elm = g_malloc(size);
> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
>          if (ret) {
>              error_report("%s: failed to load %s (%d)", field->name,
>                           vmsd->name, ret);
> diff --git a/migration/vmstate.c b/migration/vmstate.c
> index
> aeffeafaa4fa7582076a4f2747906ddf9aca891b..bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb
> 100644
> --- a/migration/vmstate.c
> +++ b/migration/vmstate.c
> @@ -132,29 +132,33 @@ static void vmstate_handle_alloc(void *ptr, const
> VMStateField *field,
>  }
>
>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> -                       void *opaque, int version_id)
> +                       void *opaque, int version_id, Error **errp)
>  {
>      const VMStateField *field = vmsd->fields;
>      int ret = 0;
>
>      trace_vmstate_load_state(vmsd->name, version_id);
>      if (version_id > vmsd->version_id) {
> -        error_report("%s: incoming version_id %d is too new "
> -                     "for local version_id %d",
> -                     vmsd->name, version_id, vmsd->version_id);
> +        error_setg(errp, "%s: incoming version_id %d is too new "
> +                   "for local version_id %d",
> +                   vmsd->name, version_id, vmsd->version_id);
>          trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
>          return -EINVAL;
>      }
>      if  (version_id < vmsd->minimum_version_id) {
> -        error_report("%s: incoming version_id %d is too old "
> -                     "for local minimum version_id  %d",
> -                     vmsd->name, version_id, vmsd->minimum_version_id);
> +        error_setg(errp, "%s: incoming version_id %d is too old "
> +                   "for local minimum version_id  %d",
> +                   vmsd->name, version_id, vmsd->minimum_version_id);
>          trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
>          return -EINVAL;
>      }
>      if (vmsd->pre_load) {
>          ret = vmsd->pre_load(opaque);
>          if (ret) {
> +            error_setg(errp, "VM pre load failed for: '%s', "
> +                       "version_id: '%d', minimum version_id: '%d', ret:
> %d",
> +                       vmsd->name, vmsd->version_id,
> vmsd->minimum_version_id,
> +                       ret);
>              return ret;
>          }
>      }
> @@ -192,10 +196,12 @@ int vmstate_load_state(QEMUFile *f, const
> VMStateDescription *vmsd,
>
>                  if (inner_field->flags & VMS_STRUCT) {
>                      ret = vmstate_load_state(f, inner_field->vmsd,
> curr_elem,
> -
>  inner_field->vmsd->version_id);
> +
>  inner_field->vmsd->version_id,
> +                                             errp);
>                  } else if (inner_field->flags & VMS_VSTRUCT) {
>                      ret = vmstate_load_state(f, inner_field->vmsd,
> curr_elem,
> -
>  inner_field->struct_version_id);
> +
>  inner_field->struct_version_id,
> +                                             errp);
>                  } else {
>                      ret = inner_field->info->get(f, curr_elem, size,
>                                                   inner_field);
> @@ -211,27 +217,34 @@ int vmstate_load_state(QEMUFile *f, const
> VMStateDescription *vmsd,
>                  }
>                  if (ret < 0) {
>                      qemu_file_set_error(f, ret);
> -                    error_report("Failed to load %s:%s", vmsd->name,
> -                                 field->name);
> +                    error_prepend(errp, "Failed to load %s:%s version_id:
> %d: ",
> +                                  vmsd->name, field->name,
> vmsd->version_id);
>                      trace_vmstate_load_field_error(field->name, ret);
>                      return ret;
>                  }
>              }
>          } else if (field->flags & VMS_MUST_EXIST) {
> -            error_report("Input validation failed: %s/%s",
> -                         vmsd->name, field->name);
> +            error_setg(errp, "Input validation failed: %s/%s version_id:
> %d",
> +                       vmsd->name, field->name, vmsd->version_id);
>              return -1;
>          }
>          field++;
>      }
>      assert(field->flags == VMS_END);
> -    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> +    ret = vmstate_subsection_load(f, vmsd, opaque, errp);
>      if (ret != 0) {
>          qemu_file_set_error(f, ret);
>          return ret;
>      }
>      if (vmsd->post_load) {
>          ret = vmsd->post_load(opaque, version_id);
> +        if (ret < 0) {
> +            error_setg(errp,
> +                       "VM Post load failed for: %s, version_id: %d, "
> +                       "minimum_version: %d, ret: %d",
> +                       vmsd->name, vmsd->version_id,
> vmsd->minimum_version_id,
> +                       ret);
> +        }
>      }
>      trace_vmstate_load_state_end(vmsd->name, "end", ret);
>      return ret;
> @@ -607,12 +620,12 @@ static int vmstate_subsection_load(QEMUFile *f,
> const VMStateDescription *vmsd,
>          qemu_file_skip(f, len); /* idstr */
>          version_id = qemu_get_be32(f);
>
> -        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> +        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id, errp);
>          if (ret) {
>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> "(child)");
> -            error_setg(errp,
> -                       "Loading VM subsection '%s' in '%s' failed : %d",
> -                       idstr, vmsd->name, ret);
> +            error_prepend(errp,
> +                          "Loading VM subsection '%s' in '%s' failed:
> '%d': ",
> +                          idstr, vmsd->name, ret);
>              return ret;
>          }
>      }
> diff --git a/tests/unit/test-vmstate.c b/tests/unit/test-vmstate.c
> index
> 63f28f26f45691a70936d33e7341d16477a3471f..ca5e0ba1e3e5e2bb0a1ce39143a292f2c6f9420a
> 100644
> --- a/tests/unit/test-vmstate.c
> +++ b/tests/unit/test-vmstate.c
> @@ -114,7 +114,7 @@ static int load_vmstate_one(const VMStateDescription
> *desc, void *obj,
>      qemu_fclose(f);
>
>      f = open_test_file(false);
> -    ret = vmstate_load_state(f, desc, obj, version);
> +    ret = vmstate_load_state(f, desc, obj, version, NULL);
>      if (ret) {
>          g_assert(qemu_file_get_error(f));
>      } else{
> @@ -365,7 +365,7 @@ static void test_load_v1(void)
>
>      QEMUFile *loading = open_test_file(false);
>      TestStruct obj = { .b = 200, .e = 500, .f = 600 };
> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 1, NULL);
>      g_assert(!qemu_file_get_error(loading));
>      g_assert_cmpint(obj.a, ==, 10);
>      g_assert_cmpint(obj.b, ==, 200);
> @@ -391,7 +391,7 @@ static void test_load_v2(void)
>
>      QEMUFile *loading = open_test_file(false);
>      TestStruct obj;
> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 2, NULL);
>      g_assert_cmpint(obj.a, ==, 10);
>      g_assert_cmpint(obj.b, ==, 20);
>      g_assert_cmpint(obj.c, ==, 30);
> @@ -480,7 +480,7 @@ static void test_load_noskip(void)
>
>      QEMUFile *loading = open_test_file(false);
>      TestStruct obj = { .skip_c_e = false };
> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
>      g_assert(!qemu_file_get_error(loading));
>      g_assert_cmpint(obj.a, ==, 10);
>      g_assert_cmpint(obj.b, ==, 20);
> @@ -504,7 +504,7 @@ static void test_load_skip(void)
>
>      QEMUFile *loading = open_test_file(false);
>      TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
>      g_assert(!qemu_file_get_error(loading));
>      g_assert_cmpint(obj.a, ==, 10);
>      g_assert_cmpint(obj.b, ==, 20);
> @@ -773,7 +773,7 @@ static void test_load_q(void)
>      TestQtailq tgt;
>
>      QTAILQ_INIT(&tgt.q);
> -    vmstate_load_state(fload, &vmstate_q, &tgt, 1);
> +    vmstate_load_state(fload, &vmstate_q, &tgt, 1, NULL);
>      char eof = qemu_get_byte(fload);
>      g_assert(!qemu_file_get_error(fload));
>      g_assert_cmpint(tgt.i16, ==, obj_q.i16);
> @@ -1127,7 +1127,7 @@ static void test_gtree_load_domain(void)
>
>      fload = open_test_file(false);
>
> -    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1);
> +    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1, NULL);
>      eof = qemu_get_byte(fload);
>      g_assert(!qemu_file_get_error(fload));
>      g_assert_cmpint(orig_domain->id, ==, dest_domain->id);
> @@ -1241,7 +1241,7 @@ static void test_gtree_load_iommu(void)
>      qemu_fclose(fsave);
>
>      fload = open_test_file(false);
> -    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1);
> +    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1, NULL);
>      eof = qemu_get_byte(fload);
>      g_assert(!qemu_file_get_error(fload));
>      g_assert_cmpint(orig_iommu->id, ==, dest_iommu->id);
> @@ -1376,7 +1376,7 @@ static void test_load_qlist(void)
>      qemu_fclose(fsave);
>
>      fload = open_test_file(false);
> -    vmstate_load_state(fload, &vmstate_container, dest_container, 1);
> +    vmstate_load_state(fload, &vmstate_container, dest_container, 1,
> NULL);
>      eof = qemu_get_byte(fload);
>      g_assert(!qemu_file_get_error(fload));
>      g_assert_cmpint(eof, ==, QEMU_VM_EOF);
> diff --git a/ui/vdagent.c b/ui/vdagent.c
> index
> c0746fe5b168fdc7aeb4866de2ba0c3387566649..83457dee0767433ad0778b37b41b9c673a0e1860
> 100644
> --- a/ui/vdagent.c
> +++ b/ui/vdagent.c
> @@ -1008,7 +1008,7 @@ static int get_cbinfo(QEMUFile *f, void *pv, size_t
> size,
>
>      vdagent_clipboard_peer_register(vd);
>
> -    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0);
> +    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0, NULL);
>      if (ret) {
>          return ret;
>      }
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 25457 bytes --]

Re: [PATCH v7 03/24] migration: push Error **errp into qemu_loadvm_state_header()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 3143 bytes --]

On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that qemu_loadvm_state_header() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/savevm.c | 27 ++++++++++++++++++---------
>  1 file changed, 18 insertions(+), 9 deletions(-)
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> ab947620f724874f325fb9fb59bef50b7c16fb51..842ff3dc6d5ccb05f7d33cef9f7319b141419501
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -2814,35 +2814,44 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t
> type)
>      return 0;
>  }
>
> -static int qemu_loadvm_state_header(QEMUFile *f)
> +static int qemu_loadvm_state_header(QEMUFile *f, Error **errp)
>  {
>      unsigned int v;
>      int ret;
>
>      v = qemu_get_be32(f);
>      if (v != QEMU_VM_FILE_MAGIC) {
> -        error_report("Not a migration stream");
> +        error_setg(errp, "Not a migration stream, magic: %x != %x",
> +                   v, QEMU_VM_FILE_MAGIC);
>          return -EINVAL;
>      }
>
>      v = qemu_get_be32(f);
>      if (v == QEMU_VM_FILE_VERSION_COMPAT) {
> -        error_report("SaveVM v2 format is obsolete and don't work
> anymore");
> +        error_setg(errp,
> +                   "SaveVM v2 format is obsolete and no longer supported,
> "
> +                   "file version %x != %x",
> +                   v, QEMU_VM_FILE_VERSION_COMPAT);
> +
>          return -ENOTSUP;
>      }
>      if (v != QEMU_VM_FILE_VERSION) {
> -        error_report("Unsupported migration stream version");
> +        error_setg(errp, "Unsupported migration stream version, "
> +                   "file version %x != %x",
> +                   v, QEMU_VM_FILE_VERSION);
>          return -ENOTSUP;
>      }
>
>      if (migrate_get_current()->send_configuration) {
> -        if (qemu_get_byte(f) != QEMU_VM_CONFIGURATION) {
> -            error_report("Configuration section missing");
> +        v = qemu_get_byte(f);
> +        if (v != QEMU_VM_CONFIGURATION) {
> +            error_setg(errp, "Configuration section missing, %x != %x",
> +                       v, QEMU_VM_CONFIGURATION);
>              return -EINVAL;
>          }
> -        ret = vmstate_load_state(f, &vmstate_configuration,
> &savevm_state, 0,
> -                                 NULL);
>
> +        ret = vmstate_load_state(f, &vmstate_configuration,
> &savevm_state, 0,
> +                                 errp);
>          if (ret) {
>              return ret;
>          }
> @@ -3119,7 +3128,7 @@ int qemu_loadvm_state(QEMUFile *f)
>
>      qemu_loadvm_thread_pool_create(mis);
>
> -    ret = qemu_loadvm_state_header(f);
> +    ret = qemu_loadvm_state_header(f, NULL);
>      if (ret) {
>          return ret;
>      }
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 4284 bytes --]

Re: [PATCH v7 04/24] migration: push Error **errp into vmstate_load()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 2600 bytes --]

On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that vmstate_load() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/savevm.c | 16 +++++++++++-----
>  1 file changed, 11 insertions(+), 5 deletions(-)
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> 842ff3dc6d5ccb05f7d33cef9f7319b141419501..736410be867a29efa24d749528c9bc203a3e8131
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -963,14 +963,20 @@ void vmstate_unregister(VMStateIf *obj, const
> VMStateDescription *vmsd,
>      }
>  }
>
> -static int vmstate_load(QEMUFile *f, SaveStateEntry *se)
> +static int vmstate_load(QEMUFile *f, SaveStateEntry *se, Error **errp)
>  {
> +    int ret;
>      trace_vmstate_load(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
>      if (!se->vmsd) {         /* Old style */
> -        return se->ops->load_state(f, se->opaque, se->load_version_id);
> +        ret = se->ops->load_state(f, se->opaque, se->load_version_id);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load VM version_id: '%d', ret:
> '%d'",
> +                       se->load_version_id, ret);
> +        }
> +        return ret;
>      }
>      return vmstate_load_state(f, se->vmsd, se->opaque,
> se->load_version_id,
> -                              NULL);
> +                              errp);
>  }
>
>  static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
> @@ -2741,7 +2747,7 @@ qemu_loadvm_section_start_full(QEMUFile *f, uint8_t
> type)
>          start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
>      }
>
> -    ret = vmstate_load(f, se);
> +    ret = vmstate_load(f, se, NULL);
>      if (ret < 0) {
>          error_report("error while loading state for instance 0x%"PRIx32"
> of"
>                       " device '%s'", instance_id, idstr);
> @@ -2794,7 +2800,7 @@ qemu_loadvm_section_part_end(QEMUFile *f, uint8_t
> type)
>          start_ts = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
>      }
>
> -    ret = vmstate_load(f, se);
> +    ret = vmstate_load(f, se, NULL);
>      if (ret < 0) {
>          error_report("error while loading state section id %d(%s)",
>                       section_id, se->idstr);
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 3613 bytes --]

Re: [PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Akihiko Odaki]

On 2025/07/25 21:19, Arun Menon wrote:
> - We need to have good error reporting in the callbacks in
>    VMStateDescription struct. Specifically pre_save, post_save,
>    pre_load and post_load callbacks.
> - It is not possible to change these functions everywhere in one
>    patch, therefore, we introduce a duplicate set of callbacks
>    with Error object passed to them.
> - So, in this commit, we implement 'errp' variants of these callbacks,
>    introducing an explicit Error object parameter.
> - This is a functional step towards transitioning the entire codebase
>    to the new error-parameterized functions.
> - Deliberately called in mutual exclusion from their counterparts,
>    to prevent conflicts during the transition.
> - New impls should preferentally use 'errp' variants of
>    these methods, and existing impls incrementally converted.
>    The variants without 'errp' are intended to be removed
>    once all usage is converted.
> 
> Signed-off-by: Arun Menon <armenon@redhat.com>
> ---
>   include/migration/vmstate.h | 11 ++++++++
>   migration/vmstate.c         | 62 +++++++++++++++++++++++++++++++++++++++------
>   2 files changed, 65 insertions(+), 8 deletions(-)
> 
> diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> index 056781b1c21e737583f081594d9f88b32adfd674..53fa72c1bbde399be02c88fc8745fdbb79bfd7c8 100644
> --- a/include/migration/vmstate.h
> +++ b/include/migration/vmstate.h
> @@ -200,15 +200,26 @@ struct VMStateDescription {
>        * exclusive. For this reason, also early_setup VMSDs are migrated in a
>        * QEMU_VM_SECTION_FULL section, while save_setup() data is migrated in
>        * a QEMU_VM_SECTION_START section.
> +     *
> +     * There are duplicate impls of the post/pre save/load hooks.
> +     * New impls should preferentally use 'errp' variants of these
> +     * methods and existing impls incrementally converted.
> +     * The variants without 'errp' are intended to be removed
> +     * once all usage is converted.
>        */
> +
>       bool early_setup;
>       int version_id;
>       int minimum_version_id;
>       MigrationPriority priority;
>       int (*pre_load)(void *opaque);
> +    int (*pre_load_errp)(void *opaque, Error **errp);
>       int (*post_load)(void *opaque, int version_id);
> +    int (*post_load_errp)(void *opaque, int version_id, Error **errp);
>       int (*pre_save)(void *opaque);
> +    int (*pre_save_errp)(void *opaque, Error **errp);
>       int (*post_save)(void *opaque);
> +    int (*post_save_errp)(void *opaque, Error **errp);
>       bool (*needed)(void *opaque);
>       bool (*dev_unplug_pending)(void *opaque);
>   
> diff --git a/migration/vmstate.c b/migration/vmstate.c
> index bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb..e427ef49b2b1991b0a3cdb14d641c197e00014b0 100644
> --- a/migration/vmstate.c
> +++ b/migration/vmstate.c
> @@ -152,7 +152,16 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
>           trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
>           return -EINVAL;
>       }
> -    if (vmsd->pre_load) {
> +    if (vmsd->pre_load_errp) {
> +        ret = vmsd->pre_load_errp(opaque, errp);
> +        if (ret) {
> +            error_prepend(errp, "VM pre load failed for: '%s', "
> +                          "version_id: '%d', minimum version_id: '%d', "
> +                          "ret: %d: ", vmsd->name, vmsd->version_id,
> +                          vmsd->minimum_version_id, ret);
> +            return ret;
> +        }
> +    } else if (vmsd->pre_load) {
>           ret = vmsd->pre_load(opaque);
>           if (ret) {
>               error_setg(errp, "VM pre load failed for: '%s', "
> @@ -236,7 +245,14 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
>           qemu_file_set_error(f, ret);
>           return ret;
>       }
> -    if (vmsd->post_load) {
> +    if (vmsd->post_load_errp) {
> +        ret = vmsd->post_load_errp(opaque, version_id, errp);
> +        if (ret < 0) {
> +            error_prepend(errp, "VM Post load failed for: %s, version_id: %d, "
> +                          "minimum_version: %d, ret: %d: ", vmsd->name,
> +                          vmsd->version_id, vmsd->minimum_version_id, ret);
> +        }
> +    } else if (vmsd->post_load) {
>           ret = vmsd->post_load(opaque, version_id);
>           if (ret < 0) {
>               error_setg(errp,
> @@ -412,11 +428,19 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
>                            void *opaque, JSONWriter *vmdesc, int version_id, Error **errp)
>   {
>       int ret = 0;
> +    Error *local_err = NULL;
>       const VMStateField *field = vmsd->fields;
>   
>       trace_vmstate_save_state_top(vmsd->name);
>   
> -    if (vmsd->pre_save) {
> +    if (vmsd->pre_save_errp) {
> +        ret = vmsd->pre_save_errp(opaque, errp);
> +        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> +        if (ret) {
> +            error_prepend(errp, "pre-save failed: %s: ", vmsd->name);
> +            return ret;
> +        }
> +    } else if (vmsd->pre_save) {
>           ret = vmsd->pre_save(opaque);
>           trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
>           if (ret) {
> @@ -524,10 +548,22 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
>                   }
>   
>                   if (ret) {
> -                    error_setg(errp, "Save of field %s/%s failed",
> -                                vmsd->name, field->name);
> -                    if (vmsd->post_save) {
> -                        vmsd->post_save(opaque);
> +                    if (*errp == NULL) {

include/qapi/error.h says:
 >  * - You may pass NULL to not receive the error, &error_abort to abort
 >  *   on error, &error_fatal to exit(1) on error, or a pointer to a
 >  *   variable containing NULL to receive the error.

 >  * - The function may pass @errp to functions it calls to pass on
 >  *   their errors to its caller.  If it dereferences @errp to check
 >  *   for errors, it must use ERRP_GUARD().

I also think this change is irrelevant with the addition of the new 
'errp' variants; it fixes an assertion failure when 
vmstate_save_state_v() failed and set errp. It is not a new problem 
caused by the 'errp' variants.

If that's true, this change should have its own explanation in the patch 
message, and also be split into another patch as "a commit message that 
mentions 'Also, ...' is often a good candidate for splitting into 
multiple patches." (docs/devel/submitting-a-patch.rst)

> +                        error_setg(errp, "Save of field %s/%s failed",
> +                                   vmsd->name, field->name);
> +                    }
> +                    if (vmsd->post_save_errp) {
> +                        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> +                        if (ps_ret < 0) {

The error checks else this and next ps_ret checks only care if it's zero 
or not, but this checks for the sign, leading to inconsistency.

> +                            error_free_or_abort(errp);
> +                            error_propagate(errp, local_err);
> +                            ret = ps_ret;
> +                        }
> +                    } else if (vmsd->post_save) {
> +                        int ps_ret = vmsd->post_save(opaque);
> +                        if (ps_ret < 0) {
> +                            ret = ps_ret;
> +                        }
>                       }
>                       return ret;
>                   }
> @@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
>   
>       ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
>   
> -    if (vmsd->post_save) {
> +    if (vmsd->post_save_errp) {
> +        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> +        if (!ret && ps_ret) {
> +            ret = ps_ret;
> +            error_propagate(errp, local_err);
> +        } else if (ret && ps_ret) {
> +            error_free_or_abort(errp);
> +            error_propagate(errp, local_err);
> +            ret = ps_ret;
> +        }

Simpler:

if (ps_ret) {
     if (ret) {
       error_free_or_abort(errp);
     }
     ret = ps_ret;
     error_propagate(errp, local_err);
}

> +    } else if (vmsd->post_save) {
>           int ps_ret = vmsd->post_save(opaque);
>           if (!ret && ps_ret) {
>               ret = ps_ret;

When there is a preceding error, this code still returns it and 
dismisses the post_save() error although the other part of this function 
is changed to propagate the error of post-save unconditionally. Please 
keep them consistent.

> 

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 3567 bytes --]

Hi

On Fri, Jul 25, 2025 at 5:46 PM Marc-André Lureau <
marcandre.lureau@redhat.com> wrote:

>
>
> On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
>
>> This is an incremental step in converting vmstate loading
>> code to report error via Error objects instead of directly
>> printing it to console/monitor.
>> It is ensured that vmstate_subsection_load() must report an error
>> in errp, in case of failure.
>>
>> Signed-off-by: Arun Menon <armenon@redhat.com>
>> ---
>>  migration/vmstate.c | 11 ++++++++---
>>  1 file changed, 8 insertions(+), 3 deletions(-)
>>
>> diff --git a/migration/vmstate.c b/migration/vmstate.c
>> index
>> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
>> 100644
>> --- a/migration/vmstate.c
>> +++ b/migration/vmstate.c
>> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>                                     void *opaque, JSONWriter *vmdesc,
>>                                     Error **errp);
>>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
>> *vmsd,
>> -                                   void *opaque);
>> +                                   void *opaque, Error **errp);
>>
>>  /* Whether this field should exist for either save or load the VM? */
>>  static bool
>> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>          field++;
>>      }
>>      assert(field->flags == VMS_END);
>> -    ret = vmstate_subsection_load(f, vmsd, opaque);
>> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
>>      if (ret != 0) {
>>          qemu_file_set_error(f, ret);
>>          return ret;
>> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
>> const *sub,
>>  }
>>
>>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
>> *vmsd,
>> -                                   void *opaque)
>> +                                   void *opaque, Error **errp)
>>  {
>>      trace_vmstate_subsection_load(vmsd->name);
>>
>> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
>>          if (sub_vmsd == NULL) {
>>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
>> "(lookup)");
>> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
>> +                       idstr, vmsd->name);
>>              return -ENOENT;
>>          }
>>          qemu_file_skip(f, 1); /* subsection */
>> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
>>          if (ret) {
>>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
>> "(child)");
>> +            error_setg(errp,
>> +                       "Loading VM subsection '%s' in '%s' failed : %d",
>>
>
> extra space before ":"
>
> other than that
> Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>

Actually, almost systematically when you introduce an extra **errp
argument, you should ERRP_GUARD() in the function (see include/qapi/error.h
doc). Was this discussed before? Can you update the following patches too?


>
>> +                       idstr, vmsd->name, ret);
>>              return ret;
>>          }
>>      }
>>
>> --
>> 2.50.0
>>
>>

[-- Attachment #2: Type: text/html, Size: 5140 bytes --]

Re: [PATCH v7 07/24] migration: Update qemu_file_get_return_path() docs and remove dead checks

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 4170 bytes --]

On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:

> The documentation of qemu_file_get_return_path() states that it can
> return NULL on failure. However, a review of the current implementation
> reveals that it is guaranteed that it will always succeed and will never
> return NULL.
>
> As a result, the NULL checks post calling the function become redundant.
> This commit updates the documentation for the function and removes all
> NULL checks throughout the migration code.
>
> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/colo.c      |  4 ----
>  migration/migration.c | 12 ++----------
>  migration/qemu-file.c |  1 -
>  migration/savevm.c    |  4 ----
>  4 files changed, 2 insertions(+), 19 deletions(-)
>
> diff --git a/migration/colo.c b/migration/colo.c
> index
> e0f713c837f5da25d67afbd02ceb6c54024ca3af..981bd4bf9ced8b45b4c5d494acae119a174ee974
> 100644
> --- a/migration/colo.c
> +++ b/migration/colo.c
> @@ -849,10 +849,6 @@ static void *colo_process_incoming_thread(void
> *opaque)
>      failover_init_state();
>
>      mis->to_src_file = qemu_file_get_return_path(mis->from_src_file);
> -    if (!mis->to_src_file) {
> -        error_report("COLO incoming thread: Open QEMUFile to_src_file
> failed");
> -        goto out;
> -    }
>      /*
>       * Note: the communication between Primary side and Secondary side
>       * should be sequential, we set the fd to unblocked in migration
> incoming
> diff --git a/migration/migration.c b/migration/migration.c
> index
> 10c216d25dec01f206eacad2edd24d21f00e614c..b3bccaeaee806abd01595863f6475057049b0688
> 100644
> --- a/migration/migration.c
> +++ b/migration/migration.c
> @@ -2646,12 +2646,9 @@ out:
>      return NULL;
>  }
>
> -static int open_return_path_on_source(MigrationState *ms)
> +static void open_return_path_on_source(MigrationState *ms)
>  {
>      ms->rp_state.from_dst_file =
> qemu_file_get_return_path(ms->to_dst_file);
> -    if (!ms->rp_state.from_dst_file) {
> -        return -1;
> -    }
>
>      trace_open_return_path_on_source();
>
> @@ -2660,8 +2657,6 @@ static int open_return_path_on_source(MigrationState
> *ms)
>      ms->rp_state.rp_thread_created = true;
>
>      trace_open_return_path_on_source_continue();
> -
> -    return 0;
>  }
>
>  /* Return true if error detected, or false otherwise */
> @@ -4010,10 +4005,7 @@ void migration_connect(MigrationState *s, Error
> *error_in)
>       * QEMU uses the return path.
>       */
>      if (migrate_postcopy_ram() || migrate_return_path()) {
> -        if (open_return_path_on_source(s)) {
> -            error_setg(&local_err, "Unable to open return-path for
> postcopy");
> -            goto fail;
> -        }
> +        open_return_path_on_source(s);
>      }
>
>      /*
> diff --git a/migration/qemu-file.c b/migration/qemu-file.c
> index
> b6ac190034f777dbde0da1598483a892089d7538..f9ccee9a1091ecbd37e6b7d2081a4446442b544d
> 100644
> --- a/migration/qemu-file.c
> +++ b/migration/qemu-file.c
> @@ -125,7 +125,6 @@ static QEMUFile *qemu_file_new_impl(QIOChannel *ioc,
> bool is_writable)
>
>  /*
>   * Result: QEMUFile* for a 'return path' for comms in the opposite
> direction
> - *         NULL if not available
>   */
>  QEMUFile *qemu_file_get_return_path(QEMUFile *f)
>  {
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> 21899e6beee3d2661c9a694379039e82cefbee4f..d8f5f1966fda831899596173f20fbef25d78829d
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -2583,10 +2583,6 @@ static int loadvm_process_command(QEMUFile *f)
>              return 0;
>          }
>          mis->to_src_file = qemu_file_get_return_path(f);
> -        if (!mis->to_src_file) {
> -            error_report("CMD_OPEN_RETURN_PATH failed");
> -            return -1;
> -        }
>
>          /*
>           * Switchover ack is enabled but no device uses it, so send an
> ACK to
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 5235 bytes --]

Re: [PATCH v7 09/24] migration: push Error **errp into loadvm_process_command()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 6589 bytes --]

Hi

On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that loadvm_process_command() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
> ---
>  migration/savevm.c | 73
> +++++++++++++++++++++++++++++++++++++++---------------
>  1 file changed, 53 insertions(+), 20 deletions(-)
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> ad96da3651b89023e4b70ffeecab46d176bae6f5..d40b25d74be46b209be8f28d10b7538a5ff2e3dd
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -2544,12 +2544,13 @@ static int
> loadvm_postcopy_handle_switchover_start(void)
>   * LOADVM_QUIT All good, but exit the loop
>   * <0          Error
>   */
> -static int loadvm_process_command(QEMUFile *f)
> +static int loadvm_process_command(QEMUFile *f, Error **errp)
>  {
>

better with ERRP_GUARD


>      MigrationIncomingState *mis = migration_incoming_get_current();
>      uint16_t cmd;
>      uint16_t len;
>      uint32_t tmp32;
> +    int ret;
>
>      cmd = qemu_get_be16(f);
>      len = qemu_get_be16(f);
> @@ -2560,16 +2561,16 @@ static int loadvm_process_command(QEMUFile *f)
>      }
>
>      if (cmd >= MIG_CMD_MAX || cmd == MIG_CMD_INVALID) {
> -        error_report("MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
> +        error_setg(errp, "MIG_CMD 0x%x unknown (len 0x%x)", cmd, len);
>          return -EINVAL;
>      }
>
>      trace_loadvm_process_command(mig_cmd_args[cmd].name, len);
>
>      if (mig_cmd_args[cmd].len != -1 && mig_cmd_args[cmd].len != len) {
> -        error_report("%s received with bad length - expecting %zu, got
> %d",
> -                     mig_cmd_args[cmd].name,
> -                     (size_t)mig_cmd_args[cmd].len, len);
> +        error_setg(errp, "%s received with bad length - expecting %zu,
> got %d",
> +                   mig_cmd_args[cmd].name,
> +                   (size_t)mig_cmd_args[cmd].len, len);
>          return -ERANGE;
>      }
>
> @@ -2588,11 +2589,11 @@ static int loadvm_process_command(QEMUFile *f)
>           * been created.
>           */
>          if (migrate_switchover_ack() && !mis->switchover_ack_pending_num)
> {
> -            int ret = migrate_send_rp_switchover_ack(mis);
> +            ret = migrate_send_rp_switchover_ack(mis);
>              if (ret) {
> -                error_report(
> -                    "Could not send switchover ack RP MSG, err %d (%s)",
> ret,
> -                    strerror(-ret));
> +                error_setg(errp,
> +                           "Could not send switchover ack RP MSG, err %d
> (%s)",
> +                           ret, strerror(-ret));
>

You could switch to using "error_setg_errno(errp, -ret.."  instead.

                 return ret;
>              }
>          }
> @@ -2602,40 +2603,72 @@ static int loadvm_process_command(QEMUFile *f)
>          tmp32 = qemu_get_be32(f);
>          trace_loadvm_process_command_ping(tmp32);
>          if (!mis->to_src_file) {
> -            error_report("CMD_PING (0x%x) received with no return path",
> -                         tmp32);
> +            error_setg(errp, "CMD_PING (0x%x) received with no return
> path",
> +                       tmp32);
>              return -1;
>          }
>          migrate_send_rp_pong(mis, tmp32);
>          break;
>
>      case MIG_CMD_PACKAGED:
> -        return loadvm_handle_cmd_packaged(mis);
> +        ret = loadvm_handle_cmd_packaged(mis);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_POSTCOPY_ADVISE:
> -        return loadvm_postcopy_handle_advise(mis, len);
> +        ret = loadvm_postcopy_handle_advise(mis, len);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_POSTCOPY_LISTEN:
> -        return loadvm_postcopy_handle_listen(mis);
> +        ret = loadvm_postcopy_handle_listen(mis);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_POSTCOPY_RUN:
> -        return loadvm_postcopy_handle_run(mis);
> +        ret = loadvm_postcopy_handle_run(mis);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_POSTCOPY_RAM_DISCARD:
> -        return loadvm_postcopy_ram_handle_discard(mis, len);
> +        ret = loadvm_postcopy_ram_handle_discard(mis, len);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_POSTCOPY_RESUME:
>          loadvm_postcopy_handle_resume(mis);
>          return 0;
>
>      case MIG_CMD_RECV_BITMAP:
> -        return loadvm_handle_recv_bitmap(mis, len);
> +        ret = loadvm_handle_recv_bitmap(mis, len);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_ENABLE_COLO:
> -        return loadvm_process_enable_colo(mis);
> +        ret = loadvm_process_enable_colo(mis);
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>
>      case MIG_CMD_SWITCHOVER_START:
> -        return loadvm_postcopy_handle_switchover_start();
> +        ret = loadvm_postcopy_handle_switchover_start();
> +        if (ret < 0) {
> +            error_setg(errp, "Failed to load device state command: %d",
> ret);
> +        }
> +        return ret;
>      }
>
>      return 0;
> @@ -3075,7 +3108,7 @@ retry:
>              }
>              break;
>          case QEMU_VM_COMMAND:
> -            ret = loadvm_process_command(f);
> +            ret = loadvm_process_command(f, NULL);
>              trace_qemu_loadvm_state_section_command(ret);
>              if ((ret < 0) || (ret == LOADVM_QUIT)) {
>                  goto out;
>
> --
> 2.50.0
>


Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>

[-- Attachment #2: Type: text/html, Size: 8515 bytes --]

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Daniel P. Berrangé]

On Mon, Jul 28, 2025 at 12:44:53PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 5:46 PM Marc-André Lureau <
> marcandre.lureau@redhat.com> wrote:
> 
> >
> >
> > On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
> >
> >> This is an incremental step in converting vmstate loading
> >> code to report error via Error objects instead of directly
> >> printing it to console/monitor.
> >> It is ensured that vmstate_subsection_load() must report an error
> >> in errp, in case of failure.
> >>
> >> Signed-off-by: Arun Menon <armenon@redhat.com>
> >> ---
> >>  migration/vmstate.c | 11 ++++++++---
> >>  1 file changed, 8 insertions(+), 3 deletions(-)
> >>
> >> diff --git a/migration/vmstate.c b/migration/vmstate.c
> >> index
> >> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
> >> 100644
> >> --- a/migration/vmstate.c
> >> +++ b/migration/vmstate.c
> >> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>                                     void *opaque, JSONWriter *vmdesc,
> >>                                     Error **errp);
> >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> >> *vmsd,
> >> -                                   void *opaque);
> >> +                                   void *opaque, Error **errp);
> >>
> >>  /* Whether this field should exist for either save or load the VM? */
> >>  static bool
> >> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          field++;
> >>      }
> >>      assert(field->flags == VMS_END);
> >> -    ret = vmstate_subsection_load(f, vmsd, opaque);
> >> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> >>      if (ret != 0) {
> >>          qemu_file_set_error(f, ret);
> >>          return ret;
> >> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
> >> const *sub,
> >>  }
> >>
> >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> >> *vmsd,
> >> -                                   void *opaque)
> >> +                                   void *opaque, Error **errp)
> >>  {
> >>      trace_vmstate_subsection_load(vmsd->name);
> >>
> >> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
> >>          if (sub_vmsd == NULL) {
> >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> >> "(lookup)");
> >> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
> >> +                       idstr, vmsd->name);
> >>              return -ENOENT;
> >>          }
> >>          qemu_file_skip(f, 1); /* subsection */
> >> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> >>          if (ret) {
> >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> >> "(child)");
> >> +            error_setg(errp,
> >> +                       "Loading VM subsection '%s' in '%s' failed : %d",
> >>
> >
> > extra space before ":"
> >
> > other than that
> > Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> 
> Actually, almost systematically when you introduce an extra **errp
> argument, you should ERRP_GUARD() in the function (see include/qapi/error.h
> doc). Was this discussed before? Can you update the following patches too?

ERRP_GUARD is only needed in functions which derefence errp, which should
very rarely be needed when all functions are non-void return value.


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 :|

Re: [PATCH v7 09/24] migration: push Error **errp into loadvm_process_command()

[Daniel P. Berrangé]

On Mon, Jul 28, 2025 at 12:53:07PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:
> 
> > This is an incremental step in converting vmstate loading
> > code to report error via Error objects instead of directly
> > printing it to console/monitor.
> > It is ensured that loadvm_process_command() must report an error
> > in errp, in case of failure.
> >
> > Signed-off-by: Arun Menon <armenon@redhat.com>
> > ---
> >  migration/savevm.c | 73
> > +++++++++++++++++++++++++++++++++++++++---------------
> >  1 file changed, 53 insertions(+), 20 deletions(-)
> >
> > diff --git a/migration/savevm.c b/migration/savevm.c
> > index
> > ad96da3651b89023e4b70ffeecab46d176bae6f5..d40b25d74be46b209be8f28d10b7538a5ff2e3dd
> > 100644
> > --- a/migration/savevm.c
> > +++ b/migration/savevm.c
> > @@ -2544,12 +2544,13 @@ static int
> > loadvm_postcopy_handle_switchover_start(void)
> >   * LOADVM_QUIT All good, but exit the loop
> >   * <0          Error
> >   */
> > -static int loadvm_process_command(QEMUFile *f)
> > +static int loadvm_process_command(QEMUFile *f, Error **errp)
> >  {
> >
> 
> better with ERRP_GUARD

Nothing in this patch derefences errp, so ERRP_GUARD is redundant.


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 :|

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Marc-André Lureau]

Hi

On Mon, Jul 28, 2025 at 1:06 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> On Mon, Jul 28, 2025 at 12:44:53PM +0400, Marc-André Lureau wrote:
> > Hi
> >
> > On Fri, Jul 25, 2025 at 5:46 PM Marc-André Lureau <
> > marcandre.lureau@redhat.com> wrote:
> >
> > >
> > >
> > > On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
> > >
> > >> This is an incremental step in converting vmstate loading
> > >> code to report error via Error objects instead of directly
> > >> printing it to console/monitor.
> > >> It is ensured that vmstate_subsection_load() must report an error
> > >> in errp, in case of failure.
> > >>
> > >> Signed-off-by: Arun Menon <armenon@redhat.com>
> > >> ---
> > >>  migration/vmstate.c | 11 ++++++++---
> > >>  1 file changed, 8 insertions(+), 3 deletions(-)
> > >>
> > >> diff --git a/migration/vmstate.c b/migration/vmstate.c
> > >> index
> > >> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
> > >> 100644
> > >> --- a/migration/vmstate.c
> > >> +++ b/migration/vmstate.c
> > >> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
> > >> VMStateDescription *vmsd,
> > >>                                     void *opaque, JSONWriter *vmdesc,
> > >>                                     Error **errp);
> > >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> > >> *vmsd,
> > >> -                                   void *opaque);
> > >> +                                   void *opaque, Error **errp);
> > >>
> > >>  /* Whether this field should exist for either save or load the VM? */
> > >>  static bool
> > >> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
> > >> VMStateDescription *vmsd,
> > >>          field++;
> > >>      }
> > >>      assert(field->flags == VMS_END);
> > >> -    ret = vmstate_subsection_load(f, vmsd, opaque);
> > >> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> > >>      if (ret != 0) {
> > >>          qemu_file_set_error(f, ret);
> > >>          return ret;
> > >> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
> > >> const *sub,
> > >>  }
> > >>
> > >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> > >> *vmsd,
> > >> -                                   void *opaque)
> > >> +                                   void *opaque, Error **errp)
> > >>  {
> > >>      trace_vmstate_subsection_load(vmsd->name);
> > >>
> > >> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
> > >> VMStateDescription *vmsd,
> > >>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
> > >>          if (sub_vmsd == NULL) {
> > >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> > >> "(lookup)");
> > >> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
> > >> +                       idstr, vmsd->name);
> > >>              return -ENOENT;
> > >>          }
> > >>          qemu_file_skip(f, 1); /* subsection */
> > >> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
> > >> VMStateDescription *vmsd,
> > >>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> > >>          if (ret) {
> > >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> > >> "(child)");
> > >> +            error_setg(errp,
> > >> +                       "Loading VM subsection '%s' in '%s' failed : %d",
> > >>
> > >
> > > extra space before ":"
> > >
> > > other than that
> > > Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> > >
> >
> > Actually, almost systematically when you introduce an extra **errp
> > argument, you should ERRP_GUARD() in the function (see include/qapi/error.h
> > doc). Was this discussed before? Can you update the following patches too?
>
> ERRP_GUARD is only needed in functions which derefence errp, which should
> very rarely be needed when all functions are non-void return value.

But also, it avoids this pitfall with @errp argument:

* - It should not be passed to error_prepend(), error_vprepend(), or
 *   error_append_hint(), because that doesn't work with &error_fatal.

either way, I don't care much, but for consistency it sounds
reasonable to ask every new function with **errp to have it.

>
>
> 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 :|
>
>


-- 
Marc-André Lureau

Re: [PATCH v7 11/24] migration: push Error **errp into ram_postcopy_incoming_init()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 5109 bytes --]

On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that ram_postcopy_incoming_init() must report an error
> in errp, in case of failure.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/postcopy-ram.c | 9 ++++++---
>  migration/postcopy-ram.h | 2 +-
>  migration/ram.c          | 4 ++--
>  migration/ram.h          | 2 +-
>  migration/savevm.c       | 2 +-
>  5 files changed, 11 insertions(+), 8 deletions(-)
>
> diff --git a/migration/postcopy-ram.c b/migration/postcopy-ram.c
> index
> 45af9a361e8eacaad0fb217a5da2c5004416c1da..05617e5fbcad62226a54fe17d9f7d9a316baf1e4
> 100644
> --- a/migration/postcopy-ram.c
> +++ b/migration/postcopy-ram.c
> @@ -681,6 +681,7 @@ out:
>   */
>  static int init_range(RAMBlock *rb, void *opaque)
>  {
> +    Error **errp = opaque;
>      const char *block_name = qemu_ram_get_idstr(rb);
>      void *host_addr = qemu_ram_get_host_addr(rb);
>      ram_addr_t offset = qemu_ram_get_offset(rb);
> @@ -701,6 +702,8 @@ static int init_range(RAMBlock *rb, void *opaque)
>       * (Precopy will just overwrite this data, so doesn't need the
> discard)
>       */
>      if (ram_discard_range(block_name, 0, length)) {
> +        error_setg(errp, "failed to discard RAM block %s len=%zu",
> +                   block_name, length);
>          return -1;
>      }
>
> @@ -749,9 +752,9 @@ static int cleanup_range(RAMBlock *rb, void *opaque)
>   * postcopy later; must be called prior to any precopy.
>   * called from arch_init's similarly named ram_postcopy_incoming_init
>   */
> -int postcopy_ram_incoming_init(MigrationIncomingState *mis)
> +int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp)
>  {
> -    if (foreach_not_ignored_block(init_range, NULL)) {
> +    if (foreach_not_ignored_block(init_range, errp)) {
>          return -1;
>      }
>
> @@ -1703,7 +1706,7 @@ bool
> postcopy_ram_supported_by_host(MigrationIncomingState *mis, Error **errp)
>      return false;
>  }
>
> -int postcopy_ram_incoming_init(MigrationIncomingState *mis)
> +int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp)
>  {
>      error_report("postcopy_ram_incoming_init: No OS support");
>      return -1;
> diff --git a/migration/postcopy-ram.h b/migration/postcopy-ram.h
> index
> 3852141d7e37ab18bada4b46c137fef0969d0070..ca19433b246893fa5105bcebffb442c58a9a4f48
> 100644
> --- a/migration/postcopy-ram.h
> +++ b/migration/postcopy-ram.h
> @@ -30,7 +30,7 @@ int postcopy_ram_incoming_setup(MigrationIncomingState
> *mis);
>   * postcopy later; must be called prior to any precopy.
>   * called from ram.c's similarly named ram_postcopy_incoming_init
>   */
> -int postcopy_ram_incoming_init(MigrationIncomingState *mis);
> +int postcopy_ram_incoming_init(MigrationIncomingState *mis, Error **errp);
>
>  /*
>   * At the end of a migration where postcopy_ram_incoming_init was called.
> diff --git a/migration/ram.c b/migration/ram.c
> index
> 7208bc114fb5c366740db380ee6956a91b3871a0..6a0dcc04f436524a37672c41c38f201f06773374
> 100644
> --- a/migration/ram.c
> +++ b/migration/ram.c
> @@ -3716,9 +3716,9 @@ static int ram_load_cleanup(void *opaque)
>   * postcopy-ram. postcopy-ram's similarly names
>   * postcopy_ram_incoming_init does the work.
>   */
> -int ram_postcopy_incoming_init(MigrationIncomingState *mis)
> +int ram_postcopy_incoming_init(MigrationIncomingState *mis, Error **errp)
>  {
> -    return postcopy_ram_incoming_init(mis);
> +    return postcopy_ram_incoming_init(mis, errp);
>  }
>
>  /**
> diff --git a/migration/ram.h b/migration/ram.h
> index
> 921c39a2c5c45bc2344be80854c46e4c10c09aeb..275709a99187f9429ccb4111e05281ec268ba0db
> 100644
> --- a/migration/ram.h
> +++ b/migration/ram.h
> @@ -86,7 +86,7 @@ void ram_postcopy_migrated_memory_release(MigrationState
> *ms);
>  void ram_postcopy_send_discard_bitmap(MigrationState *ms);
>  /* For incoming postcopy discard */
>  int ram_discard_range(const char *block_name, uint64_t start, size_t
> length);
> -int ram_postcopy_incoming_init(MigrationIncomingState *mis);
> +int ram_postcopy_incoming_init(MigrationIncomingState *mis, Error **errp);
>  int ram_load_postcopy(QEMUFile *f, int channel);
>
>  void ram_handle_zero(void *host, uint64_t size);
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> 63cf488d9f411c0fb8d5f1bc8a719aa575bbabdc..60a055f3e1f248b09e5e5d721f14d2eeafd0a7ad
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -1989,7 +1989,7 @@ static int
> loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
>          return -1;
>      }
>
> -    if (ram_postcopy_incoming_init(mis)) {
> +    if (ram_postcopy_incoming_init(mis, NULL) < 0) {
>          return -1;
>      }
>
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 6078 bytes --]

Re: [PATCH v7 12/24] migration: push Error **errp into loadvm_postcopy_handle_advise()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 5145 bytes --]

On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> It is ensured that loadvm_postcopy_handle_advise() must report an error
> in errp, in case of failure.
>
> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/savevm.c | 40 +++++++++++++++++++---------------------
>  1 file changed, 19 insertions(+), 21 deletions(-)
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> 60a055f3e1f248b09e5e5d721f14d2eeafd0a7ad..eb843f4869f7b49a17fe0fb1b0e36db993e4024e
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -1912,39 +1912,39 @@ enum LoadVMExitCodes {
>   * quickly.
>   */
>  static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
> -                                         uint16_t len)
> +                                         uint16_t len, Error **errp)
>  {
>      PostcopyState ps = postcopy_state_set(POSTCOPY_INCOMING_ADVISE);
>      uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;
>      size_t page_size = qemu_target_page_size();
> -    Error *local_err = NULL;
>
>      trace_loadvm_postcopy_handle_advise();
>      if (ps != POSTCOPY_INCOMING_NONE) {
> -        error_report("CMD_POSTCOPY_ADVISE in wrong postcopy state (%d)",
> ps);
> +        error_setg(errp, "CMD_POSTCOPY_ADVISE in wrong postcopy state
> (%d)",
> +                   ps);
>          return -1;
>      }
>
>      switch (len) {
>      case 0:
>          if (migrate_postcopy_ram()) {
> -            error_report("RAM postcopy is enabled but have 0 byte
> advise");
> +            error_setg(errp, "RAM postcopy is enabled but have 0 byte
> advise");
>              return -EINVAL;
>          }
>          return 0;
>      case 8 + 8:
>          if (!migrate_postcopy_ram()) {
> -            error_report("RAM postcopy is disabled but have 16 byte
> advise");
> +            error_setg(errp,
> +                       "RAM postcopy is disabled but have 16 byte
> advise");
>              return -EINVAL;
>          }
>          break;
>      default:
> -        error_report("CMD_POSTCOPY_ADVISE invalid length (%d)", len);
> +        error_setg(errp, "CMD_POSTCOPY_ADVISE invalid length (%d)", len);
>          return -EINVAL;
>      }
>
> -    if (!postcopy_ram_supported_by_host(mis, &local_err)) {
> -        error_report_err(local_err);
> +    if (!postcopy_ram_supported_by_host(mis, errp)) {
>          postcopy_state_set(POSTCOPY_INCOMING_NONE);
>          return -1;
>      }
> @@ -1967,9 +1967,10 @@ static int
> loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
>           *      also fails when passed to an older qemu that doesn't
>           *      do huge pages.
>           */
> -        error_report("Postcopy needs matching RAM page sizes (s=%" PRIx64
> -                                                             " d=%"
> PRIx64 ")",
> -                     remote_pagesize_summary, local_pagesize_summary);
> +        error_setg(errp,
> +                   "Postcopy needs matching RAM page sizes "
> +                   "(s=%" PRIx64 " d=%" PRIx64 ")",
> +                   remote_pagesize_summary, local_pagesize_summary);
>          return -1;
>      }
>
> @@ -1979,17 +1980,18 @@ static int
> loadvm_postcopy_handle_advise(MigrationIncomingState *mis,
>           * Again, some differences could be dealt with, but for now keep
> it
>           * simple.
>           */
> -        error_report("Postcopy needs matching target page sizes (s=%d
> d=%zd)",
> -                     (int)remote_tps, page_size);
> +        error_setg(errp,
> +                   "Postcopy needs matching target page sizes (s=%d
> d=%zd)",
> +                   (int)remote_tps, page_size);
>          return -1;
>      }
>
> -    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, &local_err)) {
> -        error_report_err(local_err);
> +    if (postcopy_notify(POSTCOPY_NOTIFY_INBOUND_ADVISE, errp)) {
>          return -1;
>      }
>
> -    if (ram_postcopy_incoming_init(mis, NULL) < 0) {
> +    if (ram_postcopy_incoming_init(mis, errp) < 0) {
> +        error_prepend(errp, "Postcopy RAM incoming init failed: ");
>          return -1;
>      }
>
> @@ -2617,11 +2619,7 @@ static int loadvm_process_command(QEMUFile *f,
> Error **errp)
>          return loadvm_handle_cmd_packaged(mis, errp);
>
>      case MIG_CMD_POSTCOPY_ADVISE:
> -        ret = loadvm_postcopy_handle_advise(mis, len);
> -        if (ret < 0) {
> -            error_setg(errp, "Failed to load device state command: %d",
> ret);
> -        }
> -        return ret;
> +        return loadvm_postcopy_handle_advise(mis, len, errp);
>
>      case MIG_CMD_POSTCOPY_LISTEN:
>          ret = loadvm_postcopy_handle_listen(mis);
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 6689 bytes --]

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Daniel P. Berrangé]

On Mon, Jul 28, 2025 at 01:59:40PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Mon, Jul 28, 2025 at 1:06 PM Daniel P. Berrangé <berrange@redhat.com> wrote:
> >
> > On Mon, Jul 28, 2025 at 12:44:53PM +0400, Marc-André Lureau wrote:
> > > Hi
> > >
> > > On Fri, Jul 25, 2025 at 5:46 PM Marc-André Lureau <
> > > marcandre.lureau@redhat.com> wrote:
> > >
> > > >
> > > >
> > > > On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
> > > >
> > > >> This is an incremental step in converting vmstate loading
> > > >> code to report error via Error objects instead of directly
> > > >> printing it to console/monitor.
> > > >> It is ensured that vmstate_subsection_load() must report an error
> > > >> in errp, in case of failure.
> > > >>
> > > >> Signed-off-by: Arun Menon <armenon@redhat.com>
> > > >> ---
> > > >>  migration/vmstate.c | 11 ++++++++---
> > > >>  1 file changed, 8 insertions(+), 3 deletions(-)
> > > >>
> > > >> diff --git a/migration/vmstate.c b/migration/vmstate.c
> > > >> index
> > > >> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
> > > >> 100644
> > > >> --- a/migration/vmstate.c
> > > >> +++ b/migration/vmstate.c
> > > >> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
> > > >> VMStateDescription *vmsd,
> > > >>                                     void *opaque, JSONWriter *vmdesc,
> > > >>                                     Error **errp);
> > > >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> > > >> *vmsd,
> > > >> -                                   void *opaque);
> > > >> +                                   void *opaque, Error **errp);
> > > >>
> > > >>  /* Whether this field should exist for either save or load the VM? */
> > > >>  static bool
> > > >> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
> > > >> VMStateDescription *vmsd,
> > > >>          field++;
> > > >>      }
> > > >>      assert(field->flags == VMS_END);
> > > >> -    ret = vmstate_subsection_load(f, vmsd, opaque);
> > > >> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> > > >>      if (ret != 0) {
> > > >>          qemu_file_set_error(f, ret);
> > > >>          return ret;
> > > >> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
> > > >> const *sub,
> > > >>  }
> > > >>
> > > >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> > > >> *vmsd,
> > > >> -                                   void *opaque)
> > > >> +                                   void *opaque, Error **errp)
> > > >>  {
> > > >>      trace_vmstate_subsection_load(vmsd->name);
> > > >>
> > > >> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
> > > >> VMStateDescription *vmsd,
> > > >>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
> > > >>          if (sub_vmsd == NULL) {
> > > >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> > > >> "(lookup)");
> > > >> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
> > > >> +                       idstr, vmsd->name);
> > > >>              return -ENOENT;
> > > >>          }
> > > >>          qemu_file_skip(f, 1); /* subsection */
> > > >> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
> > > >> VMStateDescription *vmsd,
> > > >>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> > > >>          if (ret) {
> > > >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> > > >> "(child)");
> > > >> +            error_setg(errp,
> > > >> +                       "Loading VM subsection '%s' in '%s' failed : %d",
> > > >>
> > > >
> > > > extra space before ":"
> > > >
> > > > other than that
> > > > Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> > > >
> > >
> > > Actually, almost systematically when you introduce an extra **errp
> > > argument, you should ERRP_GUARD() in the function (see include/qapi/error.h
> > > doc). Was this discussed before? Can you update the following patches too?
> >
> > ERRP_GUARD is only needed in functions which derefence errp, which should
> > very rarely be needed when all functions are non-void return value.
> 
> But also, it avoids this pitfall with @errp argument:
> 
> * - It should not be passed to error_prepend(), error_vprepend(), or
>  *   error_append_hint(), because that doesn't work with &error_fatal.

Oh, i forgot about that gotcha :-(

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 :|

Re: [PATCH v7 02/24] migration: push Error **errp into vmstate_load_state()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 22390 bytes --]

Hi

On Fri, Jul 25, 2025 at 5:48 PM Marc-André Lureau <
marcandre.lureau@redhat.com> wrote:

>
>
> On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
>
>> This is an incremental step in converting vmstate loading
>> code to report error via Error objects instead of directly
>> printing it to console/monitor.
>> It is ensured that vmstate_load_state() must report an error
>> in errp, in case of failure.
>>
>> Signed-off-by: Arun Menon <armenon@redhat.com>
>>
>
> Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>

Actually, there is a general issue with this patch and following patches.

Whenever it replaces error_report() with error_setg*(), all the callers
should be checked or updated to report the error instead..


>
>
>> ---
>>  hw/display/virtio-gpu.c     |  2 +-
>>  hw/pci/pci.c                |  2 +-
>>  hw/s390x/virtio-ccw.c       |  2 +-
>>  hw/scsi/spapr_vscsi.c       |  2 +-
>>  hw/vfio/pci.c               |  2 +-
>>  hw/virtio/virtio-mmio.c     |  2 +-
>>  hw/virtio/virtio-pci.c      |  2 +-
>>  hw/virtio/virtio.c          |  4 ++--
>>  include/migration/vmstate.h |  2 +-
>>  migration/cpr.c             |  4 ++--
>>  migration/savevm.c          |  6 ++++--
>>  migration/vmstate-types.c   | 10 ++++-----
>>  migration/vmstate.c         | 49
>> ++++++++++++++++++++++++++++-----------------
>>  tests/unit/test-vmstate.c   | 18 ++++++++---------
>>  ui/vdagent.c                |  2 +-
>>  15 files changed, 62 insertions(+), 47 deletions(-)
>>
>> diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c
>> index
>> 0a1a625b0ea6cf26cb0d799171a57ed3d3ab2442..5d2ca8d8b864350133a674802d7316abd379591c
>> 100644
>> --- a/hw/display/virtio-gpu.c
>> +++ b/hw/display/virtio-gpu.c
>> @@ -1343,7 +1343,7 @@ 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);
>> +    vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, NULL);
>>
>
So all the added NULL arguments should probably be &error_warn (or
&error_fatal) instead.



>>      return 0;
>>  }
>> diff --git a/hw/pci/pci.c b/hw/pci/pci.c
>> index
>> c70b5ceebaf1f2b10768bd030526cbb518da2b8d..2ab5d30bb3c319ac1c7bfc9a2acf6a2b38082066
>> 100644
>> --- a/hw/pci/pci.c
>> +++ b/hw/pci/pci.c
>> @@ -934,7 +934,7 @@ void pci_device_save(PCIDevice *s, QEMUFile *f)
>>  int pci_device_load(PCIDevice *s, QEMUFile *f)
>>  {
>>      int ret;
>> -    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id);
>> +    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id,
>> NULL);
>>      /* Restore the interrupt status bit. */
>>      pci_update_irq_status(s);
>>      return ret;
>> diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
>> index
>> d2f85b39f30f7fc82e0c600144c0a958e1269b2c..2f6feff2b0a22d7d7f6aecfd7e7870d8362f1a73
>> 100644
>> --- a/hw/s390x/virtio-ccw.c
>> +++ b/hw/s390x/virtio-ccw.c
>> @@ -1136,7 +1136,7 @@ static void virtio_ccw_save_config(DeviceState *d,
>> QEMUFile *f)
>>  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);
>> +    return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, NULL);
>>  }
>>
>>  static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
>> diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c
>> index
>> 20f70fb2729de78b9636a6b8c869695dab4f8902..573fdea668536b464bca11f001e9e0288e781493
>> 100644
>> --- a/hw/scsi/spapr_vscsi.c
>> +++ b/hw/scsi/spapr_vscsi.c
>> @@ -648,7 +648,7 @@ static void *vscsi_load_request(QEMUFile *f,
>> SCSIRequest *sreq)
>>      assert(!req->active);
>>
>>      memset(req, 0, sizeof(*req));
>> -    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1);
>> +    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1, NULL);
>>      if (rc) {
>>          fprintf(stderr, "VSCSI: failed loading request tag#%u\n",
>> sreq->tag);
>>          return NULL;
>> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
>> index
>> e72d514a4cb91946f7c79332492bf5d709c308f2..498bbb96e97df50af5fc906fa00d4436c1edc05f
>> 100644
>> --- a/hw/vfio/pci.c
>> +++ b/hw/vfio/pci.c
>> @@ -2797,7 +2797,7 @@ static int vfio_pci_load_config(VFIODevice
>> *vbasedev, QEMUFile *f)
>>          old_addr[bar] = pdev->io_regions[bar].addr;
>>      }
>>
>> -    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1);
>> +    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1, NULL);
>>      if (ret) {
>>          return ret;
>>      }
>> diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c
>> index
>> 532c67107ba1d2978a76cf49f9cdc1de1dea3e11..9058b1563462d4464dcba799643a583c93fb5683
>> 100644
>> --- a/hw/virtio/virtio-mmio.c
>> +++ b/hw/virtio/virtio-mmio.c
>> @@ -619,7 +619,7 @@ static int virtio_mmio_load_extra_state(DeviceState
>> *opaque, QEMUFile *f)
>>  {
>>      VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
>>
>> -    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1);
>> +    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, NULL);
>>  }
>>
>>  static bool virtio_mmio_has_extra_state(DeviceState *opaque)
>> diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
>> index
>> 767216d795998708f5716a23ae16c79cd90ff489..f8b52a611e56c22d844fd4cae3619da4f2686d03
>> 100644
>> --- a/hw/virtio/virtio-pci.c
>> +++ b/hw/virtio/virtio-pci.c
>> @@ -161,7 +161,7 @@ static int virtio_pci_load_extra_state(DeviceState
>> *d, QEMUFile *f)
>>  {
>>      VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
>>
>> -    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1);
>> +    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, NULL);
>>  }
>>
>>  static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
>> diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
>> index
>> 2ab1d20769495ea39445b87e3673b076ad172510..d5698b062a1e95437f6113f41136e90ae06f1974
>> 100644
>> --- a/hw/virtio/virtio.c
>> +++ b/hw/virtio/virtio.c
>> @@ -3317,14 +3317,14 @@ virtio_load(VirtIODevice *vdev, QEMUFile *f, int
>> version_id)
>>      }
>>
>>      if (vdc->vmsd) {
>> -        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id);
>> +        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id, NULL);
>>          if (ret) {
>>              return ret;
>>          }
>>      }
>>
>>      /* Subsections */
>> -    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
>> +    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1, NULL);
>>      if (ret) {
>>          return ret;
>>      }
>> diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
>> index
>> 1ff7bd9ac425ba67cd5ca7ad97bcf570f9e19abe..056781b1c21e737583f081594d9f88b32adfd674
>> 100644
>> --- a/include/migration/vmstate.h
>> +++ b/include/migration/vmstate.h
>> @@ -1196,7 +1196,7 @@ extern const VMStateInfo vmstate_info_qlist;
>>      }
>>
>>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
>> -                       void *opaque, int version_id);
>> +                       void *opaque, int version_id, Error **errp);
>>  int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
>>                         void *opaque, JSONWriter *vmdesc);
>>  int vmstate_save_state_with_err(QEMUFile *f, const VMStateDescription
>> *vmsd,
>> diff --git a/migration/cpr.c b/migration/cpr.c
>> index
>> 42ad0b0d500e5de57faf0c6517e216b2d1c0cacf..9569c3f76bf8714def6406ae24f7fbc5afa4e793
>> 100644
>> --- a/migration/cpr.c
>> +++ b/migration/cpr.c
>> @@ -233,9 +233,9 @@ int cpr_state_load(MigrationChannel *channel, Error
>> **errp)
>>          return -ENOTSUP;
>>      }
>>
>> -    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1);
>> +    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1, errp);
>>      if (ret) {
>> -        error_setg(errp, "vmstate_load_state error %d", ret);
>> +        error_prepend(errp, "vmstate_load_state error %d: ", ret);
>>          qemu_fclose(f);
>>          return ret;
>>      }
>> diff --git a/migration/savevm.c b/migration/savevm.c
>> index
>> fabbeb296ae987d0c06ba6dafda63720205fecfd..ab947620f724874f325fb9fb59bef50b7c16fb51
>> 100644
>> --- a/migration/savevm.c
>> +++ b/migration/savevm.c
>> @@ -969,7 +969,8 @@ static int vmstate_load(QEMUFile *f, SaveStateEntry
>> *se)
>>      if (!se->vmsd) {         /* Old style */
>>          return se->ops->load_state(f, se->opaque, se->load_version_id);
>>      }
>> -    return vmstate_load_state(f, se->vmsd, se->opaque,
>> se->load_version_id);
>> +    return vmstate_load_state(f, se->vmsd, se->opaque,
>> se->load_version_id,
>> +                              NULL);
>>  }
>>
>>  static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
>> @@ -2839,7 +2840,8 @@ static int qemu_loadvm_state_header(QEMUFile *f)
>>              error_report("Configuration section missing");
>>              return -EINVAL;
>>          }
>> -        ret = vmstate_load_state(f, &vmstate_configuration,
>> &savevm_state, 0);
>> +        ret = vmstate_load_state(f, &vmstate_configuration,
>> &savevm_state, 0,
>> +                                 NULL);
>>
>>          if (ret) {
>>              return ret;
>> diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c
>> index
>> 741a588b7e18c6d37724b08a0101edc8bc74a0a5..1c5b76e1dd198030847971bc35637867c9d54fc0
>> 100644
>> --- a/migration/vmstate-types.c
>> +++ b/migration/vmstate-types.c
>> @@ -549,7 +549,7 @@ static int get_tmp(QEMUFile *f, void *pv, size_t size,
>>
>>      /* Writes the parent field which is at the start of the tmp */
>>      *(void **)tmp = pv;
>> -    ret = vmstate_load_state(f, vmsd, tmp, version_id);
>> +    ret = vmstate_load_state(f, vmsd, tmp, version_id, NULL);
>>      g_free(tmp);
>>      return ret;
>>  }
>> @@ -649,7 +649,7 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t
>> unused_size,
>>
>>      while (qemu_get_byte(f)) {
>>          elm = g_malloc(size);
>> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
>> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
>>          if (ret) {
>>              return ret;
>>          }
>> @@ -803,7 +803,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
>> unused_size,
>>              key = (void *)(uintptr_t)qemu_get_be64(f);
>>          } else {
>>              key = g_malloc0(key_size);
>> -            ret = vmstate_load_state(f, key_vmsd, key, version_id);
>> +            ret = vmstate_load_state(f, key_vmsd, key, version_id, NULL);
>>              if (ret) {
>>                  error_report("%s : failed to load %s (%d)",
>>                               field->name, key_vmsd->name, ret);
>> @@ -811,7 +811,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
>> unused_size,
>>              }
>>          }
>>          val = g_malloc0(val_size);
>> -        ret = vmstate_load_state(f, val_vmsd, val, version_id);
>> +        ret = vmstate_load_state(f, val_vmsd, val, version_id, NULL);
>>          if (ret) {
>>              error_report("%s : failed to load %s (%d)",
>>                           field->name, val_vmsd->name, ret);
>> @@ -892,7 +892,7 @@ static int get_qlist(QEMUFile *f, void *pv, size_t
>> unused_size,
>>
>>      while (qemu_get_byte(f)) {
>>          elm = g_malloc(size);
>> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
>> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
>>          if (ret) {
>>              error_report("%s: failed to load %s (%d)", field->name,
>>                           vmsd->name, ret);
>> diff --git a/migration/vmstate.c b/migration/vmstate.c
>> index
>> aeffeafaa4fa7582076a4f2747906ddf9aca891b..bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb
>> 100644
>> --- a/migration/vmstate.c
>> +++ b/migration/vmstate.c
>> @@ -132,29 +132,33 @@ static void vmstate_handle_alloc(void *ptr, const
>> VMStateField *field,
>>  }
>>
>>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
>> -                       void *opaque, int version_id)
>> +                       void *opaque, int version_id, Error **errp)
>>  {
>>      const VMStateField *field = vmsd->fields;
>>      int ret = 0;
>>
>>      trace_vmstate_load_state(vmsd->name, version_id);
>>      if (version_id > vmsd->version_id) {
>> -        error_report("%s: incoming version_id %d is too new "
>> -                     "for local version_id %d",
>> -                     vmsd->name, version_id, vmsd->version_id);
>> +        error_setg(errp, "%s: incoming version_id %d is too new "
>> +                   "for local version_id %d",
>> +                   vmsd->name, version_id, vmsd->version_id);
>>          trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
>>          return -EINVAL;
>>      }
>>      if  (version_id < vmsd->minimum_version_id) {
>> -        error_report("%s: incoming version_id %d is too old "
>> -                     "for local minimum version_id  %d",
>> -                     vmsd->name, version_id, vmsd->minimum_version_id);
>> +        error_setg(errp, "%s: incoming version_id %d is too old "
>> +                   "for local minimum version_id  %d",
>> +                   vmsd->name, version_id, vmsd->minimum_version_id);
>>          trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
>>          return -EINVAL;
>>      }
>>      if (vmsd->pre_load) {
>>          ret = vmsd->pre_load(opaque);
>>          if (ret) {
>> +            error_setg(errp, "VM pre load failed for: '%s', "
>> +                       "version_id: '%d', minimum version_id: '%d', ret:
>> %d",
>> +                       vmsd->name, vmsd->version_id,
>> vmsd->minimum_version_id,
>> +                       ret);
>>              return ret;
>>          }
>>      }
>> @@ -192,10 +196,12 @@ int vmstate_load_state(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>
>>                  if (inner_field->flags & VMS_STRUCT) {
>>                      ret = vmstate_load_state(f, inner_field->vmsd,
>> curr_elem,
>> -
>>  inner_field->vmsd->version_id);
>> +
>>  inner_field->vmsd->version_id,
>> +                                             errp);
>>                  } else if (inner_field->flags & VMS_VSTRUCT) {
>>                      ret = vmstate_load_state(f, inner_field->vmsd,
>> curr_elem,
>> -
>>  inner_field->struct_version_id);
>> +
>>  inner_field->struct_version_id,
>> +                                             errp);
>>                  } else {
>>                      ret = inner_field->info->get(f, curr_elem, size,
>>                                                   inner_field);
>> @@ -211,27 +217,34 @@ int vmstate_load_state(QEMUFile *f, const
>> VMStateDescription *vmsd,
>>                  }
>>                  if (ret < 0) {
>>                      qemu_file_set_error(f, ret);
>> -                    error_report("Failed to load %s:%s", vmsd->name,
>> -                                 field->name);
>> +                    error_prepend(errp, "Failed to load %s:%s
>> version_id: %d: ",
>> +                                  vmsd->name, field->name,
>> vmsd->version_id);
>>                      trace_vmstate_load_field_error(field->name, ret);
>>                      return ret;
>>                  }
>>              }
>>          } else if (field->flags & VMS_MUST_EXIST) {
>> -            error_report("Input validation failed: %s/%s",
>> -                         vmsd->name, field->name);
>> +            error_setg(errp, "Input validation failed: %s/%s version_id:
>> %d",
>> +                       vmsd->name, field->name, vmsd->version_id);
>>              return -1;
>>          }
>>          field++;
>>      }
>>      assert(field->flags == VMS_END);
>> -    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
>> +    ret = vmstate_subsection_load(f, vmsd, opaque, errp);
>>      if (ret != 0) {
>>          qemu_file_set_error(f, ret);
>>          return ret;
>>      }
>>      if (vmsd->post_load) {
>>          ret = vmsd->post_load(opaque, version_id);
>> +        if (ret < 0) {
>> +            error_setg(errp,
>> +                       "VM Post load failed for: %s, version_id: %d, "
>> +                       "minimum_version: %d, ret: %d",
>> +                       vmsd->name, vmsd->version_id,
>> vmsd->minimum_version_id,
>> +                       ret);
>> +        }
>>      }
>>      trace_vmstate_load_state_end(vmsd->name, "end", ret);
>>      return ret;
>> @@ -607,12 +620,12 @@ static int vmstate_subsection_load(QEMUFile *f,
>> const VMStateDescription *vmsd,
>>          qemu_file_skip(f, len); /* idstr */
>>          version_id = qemu_get_be32(f);
>>
>> -        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
>> +        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id, errp);
>>          if (ret) {
>>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
>> "(child)");
>> -            error_setg(errp,
>> -                       "Loading VM subsection '%s' in '%s' failed : %d",
>> -                       idstr, vmsd->name, ret);
>> +            error_prepend(errp,
>> +                          "Loading VM subsection '%s' in '%s' failed:
>> '%d': ",
>> +                          idstr, vmsd->name, ret);
>>              return ret;
>>          }
>>      }
>> diff --git a/tests/unit/test-vmstate.c b/tests/unit/test-vmstate.c
>> index
>> 63f28f26f45691a70936d33e7341d16477a3471f..ca5e0ba1e3e5e2bb0a1ce39143a292f2c6f9420a
>> 100644
>> --- a/tests/unit/test-vmstate.c
>> +++ b/tests/unit/test-vmstate.c
>> @@ -114,7 +114,7 @@ static int load_vmstate_one(const VMStateDescription
>> *desc, void *obj,
>>      qemu_fclose(f);
>>
>>      f = open_test_file(false);
>> -    ret = vmstate_load_state(f, desc, obj, version);
>> +    ret = vmstate_load_state(f, desc, obj, version, NULL);
>>      if (ret) {
>>          g_assert(qemu_file_get_error(f));
>>      } else{
>> @@ -365,7 +365,7 @@ static void test_load_v1(void)
>>
>>      QEMUFile *loading = open_test_file(false);
>>      TestStruct obj = { .b = 200, .e = 500, .f = 600 };
>> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
>> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 1, NULL);
>>      g_assert(!qemu_file_get_error(loading));
>>      g_assert_cmpint(obj.a, ==, 10);
>>      g_assert_cmpint(obj.b, ==, 200);
>> @@ -391,7 +391,7 @@ static void test_load_v2(void)
>>
>>      QEMUFile *loading = open_test_file(false);
>>      TestStruct obj;
>> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
>> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 2, NULL);
>>      g_assert_cmpint(obj.a, ==, 10);
>>      g_assert_cmpint(obj.b, ==, 20);
>>      g_assert_cmpint(obj.c, ==, 30);
>> @@ -480,7 +480,7 @@ static void test_load_noskip(void)
>>
>>      QEMUFile *loading = open_test_file(false);
>>      TestStruct obj = { .skip_c_e = false };
>> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
>> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
>>      g_assert(!qemu_file_get_error(loading));
>>      g_assert_cmpint(obj.a, ==, 10);
>>      g_assert_cmpint(obj.b, ==, 20);
>> @@ -504,7 +504,7 @@ static void test_load_skip(void)
>>
>>      QEMUFile *loading = open_test_file(false);
>>      TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
>> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
>> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
>>      g_assert(!qemu_file_get_error(loading));
>>      g_assert_cmpint(obj.a, ==, 10);
>>      g_assert_cmpint(obj.b, ==, 20);
>> @@ -773,7 +773,7 @@ static void test_load_q(void)
>>      TestQtailq tgt;
>>
>>      QTAILQ_INIT(&tgt.q);
>> -    vmstate_load_state(fload, &vmstate_q, &tgt, 1);
>> +    vmstate_load_state(fload, &vmstate_q, &tgt, 1, NULL);
>>      char eof = qemu_get_byte(fload);
>>      g_assert(!qemu_file_get_error(fload));
>>      g_assert_cmpint(tgt.i16, ==, obj_q.i16);
>> @@ -1127,7 +1127,7 @@ static void test_gtree_load_domain(void)
>>
>>      fload = open_test_file(false);
>>
>> -    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1);
>> +    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1, NULL);
>>      eof = qemu_get_byte(fload);
>>      g_assert(!qemu_file_get_error(fload));
>>      g_assert_cmpint(orig_domain->id, ==, dest_domain->id);
>> @@ -1241,7 +1241,7 @@ static void test_gtree_load_iommu(void)
>>      qemu_fclose(fsave);
>>
>>      fload = open_test_file(false);
>> -    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1);
>> +    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1, NULL);
>>      eof = qemu_get_byte(fload);
>>      g_assert(!qemu_file_get_error(fload));
>>      g_assert_cmpint(orig_iommu->id, ==, dest_iommu->id);
>> @@ -1376,7 +1376,7 @@ static void test_load_qlist(void)
>>      qemu_fclose(fsave);
>>
>>      fload = open_test_file(false);
>> -    vmstate_load_state(fload, &vmstate_container, dest_container, 1);
>> +    vmstate_load_state(fload, &vmstate_container, dest_container, 1,
>> NULL);
>>      eof = qemu_get_byte(fload);
>>      g_assert(!qemu_file_get_error(fload));
>>      g_assert_cmpint(eof, ==, QEMU_VM_EOF);
>> diff --git a/ui/vdagent.c b/ui/vdagent.c
>> index
>> c0746fe5b168fdc7aeb4866de2ba0c3387566649..83457dee0767433ad0778b37b41b9c673a0e1860
>> 100644
>> --- a/ui/vdagent.c
>> +++ b/ui/vdagent.c
>> @@ -1008,7 +1008,7 @@ static int get_cbinfo(QEMUFile *f, void *pv, size_t
>> size,
>>
>>      vdagent_clipboard_peer_register(vd);
>>
>> -    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0);
>> +    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0, NULL);
>>      if (ret) {
>>          return ret;
>>      }
>>
>> --
>> 2.50.0
>>
>>

[-- Attachment #2: Type: text/html, Size: 26822 bytes --]

Re: [PATCH v7 08/24] migration: make loadvm_postcopy_handle_resume() void

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 2060 bytes --]

Hi

On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
>
> Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
> Signed-off-by: Arun Menon <armenon@redhat.com>
> ---
>  migration/savevm.c | 11 +++++------
>  1 file changed, 5 insertions(+), 6 deletions(-)
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> d8f5f1966fda831899596173f20fbef25d78829d..ad96da3651b89023e4b70ffeecab46d176bae6f5
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -2334,12 +2334,12 @@ static void
> migrate_send_rp_req_pages_pending(MigrationIncomingState *mis)
>      }
>  }
>
> -static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
> +static void loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
>  {
>      if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
> -        error_report("%s: illegal resume received", __func__);
> +        warn_report("%s: illegal resume received", __func__);
>

Could you add a comment to the commit message to explain why this somewhat
unrelated change? thanks


>          /* Don't fail the load, only for this. */
> -        return 0;
> +        return;
>      }
>
>      /*
> @@ -2391,8 +2391,6 @@ static int
> loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
>          /* Kick the fast ram load thread too */
>          qemu_sem_post(&mis->postcopy_pause_sem_fast_load);
>      }
> -
> -    return 0;
>  }
>
>  /**
> @@ -2627,7 +2625,8 @@ static int loadvm_process_command(QEMUFile *f)
>          return loadvm_postcopy_ram_handle_discard(mis, len);
>
>      case MIG_CMD_POSTCOPY_RESUME:
> -        return loadvm_postcopy_handle_resume(mis);
> +        loadvm_postcopy_handle_resume(mis);
> +        return 0;
>
>      case MIG_CMD_RECV_BITMAP:
>          return loadvm_handle_recv_bitmap(mis, len);
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 2880 bytes --]

Re: [PATCH v7 22/24] migration: Capture error in postcopy_ram_listen_thread()

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 3266 bytes --]

On Fri, Jul 25, 2025 at 4:22 PM Arun Menon <armenon@redhat.com> wrote:

> This is an incremental step in converting vmstate loading
> code to report error via Error objects instead of directly
> printing it to console/monitor.
> postcopy_ram_listen_thread() calls qemu_loadvm_state_main()
> to load the vm, and in case of a failure, it should set the error
> in the migration object.
>
> When postcopy live migration runs, the device states are loaded by
> both the qemu coroutine process_incoming_migration_co() and the
> postcopy_ram_listen_thread(). Therefore, it is important that the
> coroutine also reports the error in case of failure, with
> error_report_err(). Otherwise, the source qemu will not display
> any errors before going into the postcopy pause state.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  migration/migration.c |  2 +-
>  migration/savevm.c    | 10 ++++++++--
>  2 files changed, 9 insertions(+), 3 deletions(-)
>
> diff --git a/migration/migration.c b/migration/migration.c
> index
> 0a5a8d5948b2b0a3f85163795e84f71903870d25..4a76d7ed730589bae87115368b0bf4819f8b161e
> 100644
> --- a/migration/migration.c
> +++ b/migration/migration.c
> @@ -925,7 +925,7 @@ fail:
>      migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
>                        MIGRATION_STATUS_FAILED);
>      migrate_set_error(s, local_err);
> -    error_free(local_err);
> +    error_report_err(local_err);
>
>      migration_incoming_state_destroy();
>
> diff --git a/migration/savevm.c b/migration/savevm.c
> index
> 810bba9799246c8d57514be0927bb474edee8e9b..202bb9f494c9185434a50967c439ce84e0b3acee
> 100644
> --- a/migration/savevm.c
> +++ b/migration/savevm.c
> @@ -2095,6 +2095,7 @@ static void *postcopy_ram_listen_thread(void *opaque)
>      QEMUFile *f = mis->from_src_file;
>      int load_res;
>      MigrationState *migr = migrate_get_current();
> +    Error *local_err = NULL;
>
>      object_ref(OBJECT(migr));
>
> @@ -2111,7 +2112,7 @@ static void *postcopy_ram_listen_thread(void *opaque)
>      qemu_file_set_blocking(f, true);
>
>      /* TODO: sanity check that only postcopiable data will be loaded here
> */
> -    load_res = qemu_loadvm_state_main(f, mis, NULL);
> +    load_res = qemu_loadvm_state_main(f, mis, &local_err);
>
>      /*
>       * This is tricky, but, mis->from_src_file can change after it
> @@ -2137,7 +2138,12 @@ static void *postcopy_ram_listen_thread(void
> *opaque)
>                           __func__, load_res);
>              load_res = 0; /* prevent further exit() */
>          } else {
> -            error_report("%s: loadvm failed: %d", __func__, load_res);
> +            if (local_err != NULL) {
> +                error_prepend(&local_err,
> +                              "loadvm failed during postcopy: %d: ",
> load_res);
> +                migrate_set_error(migr, local_err);
> +                error_report_err(local_err);
> +            }
>              migrate_set_state(&mis->state,
> MIGRATION_STATUS_POSTCOPY_ACTIVE,
>                                             MIGRATION_STATUS_FAILED);
>          }
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 4224 bytes --]

Re: [PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Arun Menon]

Hi Akihiko,

Thanks for the review.

On Sat, Jul 26, 2025 at 09:48:12PM +0900, Akihiko Odaki wrote:
> On 2025/07/25 21:19, Arun Menon wrote:
> > - We need to have good error reporting in the callbacks in
> >    VMStateDescription struct. Specifically pre_save, post_save,
> >    pre_load and post_load callbacks.
> > - It is not possible to change these functions everywhere in one
> >    patch, therefore, we introduce a duplicate set of callbacks
> >    with Error object passed to them.
> > - So, in this commit, we implement 'errp' variants of these callbacks,
> >    introducing an explicit Error object parameter.
> > - This is a functional step towards transitioning the entire codebase
> >    to the new error-parameterized functions.
> > - Deliberately called in mutual exclusion from their counterparts,
> >    to prevent conflicts during the transition.
> > - New impls should preferentally use 'errp' variants of
> >    these methods, and existing impls incrementally converted.
> >    The variants without 'errp' are intended to be removed
> >    once all usage is converted.
> > 
> > Signed-off-by: Arun Menon <armenon@redhat.com>
> > ---
> >   include/migration/vmstate.h | 11 ++++++++
> >   migration/vmstate.c         | 62 +++++++++++++++++++++++++++++++++++++++------
> >   2 files changed, 65 insertions(+), 8 deletions(-)
> > 
> > diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> > index 056781b1c21e737583f081594d9f88b32adfd674..53fa72c1bbde399be02c88fc8745fdbb79bfd7c8 100644
> > --- a/include/migration/vmstate.h
> > +++ b/include/migration/vmstate.h
> > @@ -200,15 +200,26 @@ struct VMStateDescription {
> >        * exclusive. For this reason, also early_setup VMSDs are migrated in a
> >        * QEMU_VM_SECTION_FULL section, while save_setup() data is migrated in
> >        * a QEMU_VM_SECTION_START section.
> > +     *
> > +     * There are duplicate impls of the post/pre save/load hooks.
> > +     * New impls should preferentally use 'errp' variants of these
> > +     * methods and existing impls incrementally converted.
> > +     * The variants without 'errp' are intended to be removed
> > +     * once all usage is converted.
> >        */
> > +
> >       bool early_setup;
> >       int version_id;
> >       int minimum_version_id;
> >       MigrationPriority priority;
> >       int (*pre_load)(void *opaque);
> > +    int (*pre_load_errp)(void *opaque, Error **errp);
> >       int (*post_load)(void *opaque, int version_id);
> > +    int (*post_load_errp)(void *opaque, int version_id, Error **errp);
> >       int (*pre_save)(void *opaque);
> > +    int (*pre_save_errp)(void *opaque, Error **errp);
> >       int (*post_save)(void *opaque);
> > +    int (*post_save_errp)(void *opaque, Error **errp);
> >       bool (*needed)(void *opaque);
> >       bool (*dev_unplug_pending)(void *opaque);
> > diff --git a/migration/vmstate.c b/migration/vmstate.c
> > index bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb..e427ef49b2b1991b0a3cdb14d641c197e00014b0 100644
> > --- a/migration/vmstate.c
> > +++ b/migration/vmstate.c
> > @@ -152,7 +152,16 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> >           trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
> >           return -EINVAL;
> >       }
> > -    if (vmsd->pre_load) {
> > +    if (vmsd->pre_load_errp) {
> > +        ret = vmsd->pre_load_errp(opaque, errp);
> > +        if (ret) {
> > +            error_prepend(errp, "VM pre load failed for: '%s', "
> > +                          "version_id: '%d', minimum version_id: '%d', "
> > +                          "ret: %d: ", vmsd->name, vmsd->version_id,
> > +                          vmsd->minimum_version_id, ret);
> > +            return ret;
> > +        }
> > +    } else if (vmsd->pre_load) {
> >           ret = vmsd->pre_load(opaque);
> >           if (ret) {
> >               error_setg(errp, "VM pre load failed for: '%s', "
> > @@ -236,7 +245,14 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> >           qemu_file_set_error(f, ret);
> >           return ret;
> >       }
> > -    if (vmsd->post_load) {
> > +    if (vmsd->post_load_errp) {
> > +        ret = vmsd->post_load_errp(opaque, version_id, errp);
> > +        if (ret < 0) {
> > +            error_prepend(errp, "VM Post load failed for: %s, version_id: %d, "
> > +                          "minimum_version: %d, ret: %d: ", vmsd->name,
> > +                          vmsd->version_id, vmsd->minimum_version_id, ret);
> > +        }
> > +    } else if (vmsd->post_load) {
> >           ret = vmsd->post_load(opaque, version_id);
> >           if (ret < 0) {
> >               error_setg(errp,
> > @@ -412,11 +428,19 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
> >                            void *opaque, JSONWriter *vmdesc, int version_id, Error **errp)
> >   {
> >       int ret = 0;
> > +    Error *local_err = NULL;
> >       const VMStateField *field = vmsd->fields;
> >       trace_vmstate_save_state_top(vmsd->name);
> > -    if (vmsd->pre_save) {
> > +    if (vmsd->pre_save_errp) {
> > +        ret = vmsd->pre_save_errp(opaque, errp);
> > +        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> > +        if (ret) {
> > +            error_prepend(errp, "pre-save failed: %s: ", vmsd->name);
> > +            return ret;
> > +        }
> > +    } else if (vmsd->pre_save) {
> >           ret = vmsd->pre_save(opaque);
> >           trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> >           if (ret) {
> > @@ -524,10 +548,22 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
> >                   }
> >                   if (ret) {
> > -                    error_setg(errp, "Save of field %s/%s failed",
> > -                                vmsd->name, field->name);
> > -                    if (vmsd->post_save) {
> > -                        vmsd->post_save(opaque);
> > +                    if (*errp == NULL) {
> 
> include/qapi/error.h says:
> >  * - You may pass NULL to not receive the error, &error_abort to abort
> >  *   on error, &error_fatal to exit(1) on error, or a pointer to a
> >  *   variable containing NULL to receive the error.
> 
> >  * - The function may pass @errp to functions it calls to pass on
> >  *   their errors to its caller.  If it dereferences @errp to check
> >  *   for errors, it must use ERRP_GUARD().

Yes, we can add an ERRP_GUARD() before the null check (*errp == NULL), iff we
need a check, more on that below.
> 
> I also think this change is irrelevant with the addition of the new 'errp'
> variants; it fixes an assertion failure when vmstate_save_state_v() failed
> and set errp. It is not a new problem caused by the 'errp' variants.
> 
You are right.

vmstate_save_state() function, inturn calls vmstate_save_state_v() with NULL errp.
So that can be ignored for now, as the errors will not be set in errp at all.
Calling error_setg() exclusively later, will not cause any trouble.

On the other hand,
vmstate_save_state_v() will set errp.
And I thought re-setting it here, using error_setg() will crash QEMU.
commit 848a0503422d043d541130d5e3e2f7bc147cdef9 introduced error_setg()
in place of error_report() 

However, on review, I do think nothing has changed indeed as far as
this patchset is concerned. I do wonder though, how resetting this
does not crash QEMU. Maybe I am missing something.

> If that's true, this change should have its own explanation in the patch
> message, and also be split into another patch as "a commit message that
> mentions 'Also, ...' is often a good candidate for splitting into multiple
> patches." (docs/devel/submitting-a-patch.rst)
> 
> > +                        error_setg(errp, "Save of field %s/%s failed",
> > +                                   vmsd->name, field->name);
> > +                    }
> > +                    if (vmsd->post_save_errp) {
> > +                        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> > +                        if (ps_ret < 0) {
> 
> The error checks else this and next ps_ret checks only care if it's zero or
> not, but this checks for the sign, leading to inconsistency.

Yes, I shall keep it consistent, a non-zero value means failure. No need of sign check.
> 
> > +                            error_free_or_abort(errp);
> > +                            error_propagate(errp, local_err);
> > +                            ret = ps_ret;
> > +                        }
> > +                    } else if (vmsd->post_save) {
> > +                        int ps_ret = vmsd->post_save(opaque);
> > +                        if (ps_ret < 0) {
> > +                            ret = ps_ret;
> > +                        }
> >                       }
> >                       return ret;
> >                   }
> > @@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
> >       ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
> > -    if (vmsd->post_save) {
> > +    if (vmsd->post_save_errp) {
> > +        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> > +        if (!ret && ps_ret) {
> > +            ret = ps_ret;
> > +            error_propagate(errp, local_err);
> > +        } else if (ret && ps_ret) {
> > +            error_free_or_abort(errp);
> > +            error_propagate(errp, local_err);
> > +            ret = ps_ret;
> > +        }
> 
> Simpler:
> 
> if (ps_ret) {
>     if (ret) {
>       error_free_or_abort(errp);
>     }
>     ret = ps_ret;
>     error_propagate(errp, local_err);
> }
> 
Will do.
> > +    } else if (vmsd->post_save) {
> >           int ps_ret = vmsd->post_save(opaque);
> >           if (!ret && ps_ret) {
> >               ret = ps_ret;
> 
> When there is a preceding error, this code still returns it and dismisses
> the post_save() error although the other part of this function is changed to
> propagate the error of post-save unconditionally. Please keep them
> consistent.

I do feel that in the new implementation (post_save_errp), we should be dismissing
the preceeding error and propagating the new error from post_save(). 
Because, that way, it makes sense to run the post_save_errp() part even after encountering
an error in the preceeding section (vmstate_subsection_save).

Not sure if I should change the old impl post_save to match post_save_errp,
Or should I match the new impl with the old one.
> 
> > 
> 


Regards,
Arun

Re: [PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Marc-André Lureau]

[-- Attachment #1: Type: text/plain, Size: 8753 bytes --]

Hi

On Fri, Jul 25, 2025 at 4:22 PM Arun Menon <armenon@redhat.com> wrote:

> - We need to have good error reporting in the callbacks in
>   VMStateDescription struct. Specifically pre_save, post_save,
>   pre_load and post_load callbacks.
> - It is not possible to change these functions everywhere in one
>   patch, therefore, we introduce a duplicate set of callbacks
>   with Error object passed to them.
> - So, in this commit, we implement 'errp' variants of these callbacks,
>   introducing an explicit Error object parameter.
> - This is a functional step towards transitioning the entire codebase
>   to the new error-parameterized functions.
> - Deliberately called in mutual exclusion from their counterparts,
>   to prevent conflicts during the transition.
> - New impls should preferentally use 'errp' variants of
>   these methods, and existing impls incrementally converted.
>   The variants without 'errp' are intended to be removed
>   once all usage is converted.
>
> Signed-off-by: Arun Menon <armenon@redhat.com>
> ---
>  include/migration/vmstate.h | 11 ++++++++
>  migration/vmstate.c         | 62
> +++++++++++++++++++++++++++++++++++++++------
>  2 files changed, 65 insertions(+), 8 deletions(-)
>
> diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> index
> 056781b1c21e737583f081594d9f88b32adfd674..53fa72c1bbde399be02c88fc8745fdbb79bfd7c8
> 100644
> --- a/include/migration/vmstate.h
> +++ b/include/migration/vmstate.h
> @@ -200,15 +200,26 @@ struct VMStateDescription {
>       * exclusive. For this reason, also early_setup VMSDs are migrated in
> a
>       * QEMU_VM_SECTION_FULL section, while save_setup() data is migrated
> in
>       * a QEMU_VM_SECTION_START section.
> +     *
> +     * There are duplicate impls of the post/pre save/load hooks.
> +     * New impls should preferentally use 'errp' variants of these
> +     * methods and existing impls incrementally converted.
> +     * The variants without 'errp' are intended to be removed
> +     * once all usage is converted.
>

It is not documented, but I think all the callbacks return value should be
0 on success, <0 on error with -value an error number from errno.h. Could
you document it?


>       */
> +
>      bool early_setup;
>      int version_id;
>      int minimum_version_id;
>      MigrationPriority priority;
>      int (*pre_load)(void *opaque);
> +    int (*pre_load_errp)(void *opaque, Error **errp);
>      int (*post_load)(void *opaque, int version_id);
> +    int (*post_load_errp)(void *opaque, int version_id, Error **errp);
>      int (*pre_save)(void *opaque);
> +    int (*pre_save_errp)(void *opaque, Error **errp);
>      int (*post_save)(void *opaque);
> +    int (*post_save_errp)(void *opaque, Error **errp);
>      bool (*needed)(void *opaque);
>      bool (*dev_unplug_pending)(void *opaque);
>

You will also need to update docs/devel/migration/main.rst to reflect the
new callbacks


>
> diff --git a/migration/vmstate.c b/migration/vmstate.c
> index
> bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb..e427ef49b2b1991b0a3cdb14d641c197e00014b0
> 100644
> --- a/migration/vmstate.c
> +++ b/migration/vmstate.c
> @@ -152,7 +152,16 @@ int vmstate_load_state(QEMUFile *f, const
> VMStateDescription *vmsd,
>          trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
>          return -EINVAL;
>      }
> -    if (vmsd->pre_load) {
> +    if (vmsd->pre_load_errp) {
> +        ret = vmsd->pre_load_errp(opaque, errp);
> +        if (ret) {
> +            error_prepend(errp, "VM pre load failed for: '%s', "
> +                          "version_id: '%d', minimum version_id: '%d', "
> +                          "ret: %d: ", vmsd->name, vmsd->version_id,
> +                          vmsd->minimum_version_id, ret);
>

(but we don't have error_prepend_errno, ok)


> +            return ret;

+        }
> +    } else if (vmsd->pre_load) {
>          ret = vmsd->pre_load(opaque);
>          if (ret) {
>              error_setg(errp, "VM pre load failed for: '%s', "
> @@ -236,7 +245,14 @@ int vmstate_load_state(QEMUFile *f, const
> VMStateDescription *vmsd,
>          qemu_file_set_error(f, ret);
>          return ret;
>      }
> -    if (vmsd->post_load) {
> +    if (vmsd->post_load_errp) {
> +        ret = vmsd->post_load_errp(opaque, version_id, errp);
> +        if (ret < 0) {
> +            error_prepend(errp, "VM Post load failed for: %s, version_id:
> %d, "
> +                          "minimum_version: %d, ret: %d: ", vmsd->name,
> +                          vmsd->version_id, vmsd->minimum_version_id,
> ret);
> +        }
> +    } else if (vmsd->post_load) {
>          ret = vmsd->post_load(opaque, version_id);
>          if (ret < 0) {
>              error_setg(errp,
> @@ -412,11 +428,19 @@ int vmstate_save_state_v(QEMUFile *f, const
> VMStateDescription *vmsd,
>                           void *opaque, JSONWriter *vmdesc, int
> version_id, Error **errp)
>  {
>      int ret = 0;
> +    Error *local_err = NULL;
>      const VMStateField *field = vmsd->fields;
>
>      trace_vmstate_save_state_top(vmsd->name);
>
> -    if (vmsd->pre_save) {
> +    if (vmsd->pre_save_errp) {
> +        ret = vmsd->pre_save_errp(opaque, errp);
> +        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> +        if (ret) {
> +            error_prepend(errp, "pre-save failed: %s: ", vmsd->name);
>

Here, it would be helpful to report "ret" too.


> +            return ret;
> +        }
> +    } else if (vmsd->pre_save) {
>

Imho, you should try to introduce a new helper function to call the
implemented callback appropriately and handle the non-errp case:

int the_callback(vmsd,.. **errp)
{
  ERRP_GUARD(); // mostly for consistency

  if (vmsd->the_callback_errp) {
   return vmsd->the_callback_errp(args.., errp);
  } else if (vmsd->the_callback) {
    ret =vmsd->the_callback(args...);
    error_setg_errno(-ret, "the callback failed...")
    return ret;
  }

  return 0;
}

This should make it a bit easier to deal with.

         ret = vmsd->pre_save(opaque);
>          trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
>          if (ret) {
> @@ -524,10 +548,22 @@ int vmstate_save_state_v(QEMUFile *f, const
> VMStateDescription *vmsd,
>                  }
>
>                  if (ret) {
> -                    error_setg(errp, "Save of field %s/%s failed",
> -                                vmsd->name, field->name);
> -                    if (vmsd->post_save) {
> -                        vmsd->post_save(opaque);
> +                    if (*errp == NULL) {
> +                        error_setg(errp, "Save of field %s/%s failed",
> +                                   vmsd->name, field->name);
> +                    }
> +                    if (vmsd->post_save_errp) {
> +                        int ps_ret = vmsd->post_save_errp(opaque,
> &local_err);
> +                        if (ps_ret < 0) {
> +                            error_free_or_abort(errp);
> +                            error_propagate(errp, local_err);
> +                            ret = ps_ret;
> +                        }
> +                    } else if (vmsd->post_save) {
> +                        int ps_ret = vmsd->post_save(opaque);
>

It's a bit odd how post_save() is being used here. It could be worth to
document that it is called regardless of success of migration in callback
doc.

Imho, the function vmstate_save_state_v() should be refactored to call
pre_save() and post_save() and call an internal function in between. It
will also help to shrink the function a bit.


> +                        if (ps_ret < 0) {
> +                            ret = ps_ret;
> +                        }
>                      }
>                      return ret;
>                  }
> @@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const
> VMStateDescription *vmsd,
>
>      ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
>
> -    if (vmsd->post_save) {
> +    if (vmsd->post_save_errp) {
> +        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> +        if (!ret && ps_ret) {
> +            ret = ps_ret;
> +            error_propagate(errp, local_err);
> +        } else if (ret && ps_ret) {
> +            error_free_or_abort(errp);
> +            error_propagate(errp, local_err);
> +            ret = ps_ret;
> +        }
> +    } else if (vmsd->post_save) {
>          int ps_ret = vmsd->post_save(opaque);
>          if (!ret && ps_ret) {
>              ret = ps_ret;
>
> --
> 2.50.0
>
>

[-- Attachment #2: Type: text/html, Size: 11817 bytes --]

Re: [PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Arun Menon]

Hi Marc-André,
Thanks for the review.

On Mon, Jul 28, 2025 at 03:07:25PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 4:22 PM Arun Menon <armenon@redhat.com> wrote:
> 
> > - We need to have good error reporting in the callbacks in
> >   VMStateDescription struct. Specifically pre_save, post_save,
> >   pre_load and post_load callbacks.
> > - It is not possible to change these functions everywhere in one
> >   patch, therefore, we introduce a duplicate set of callbacks
> >   with Error object passed to them.
> > - So, in this commit, we implement 'errp' variants of these callbacks,
> >   introducing an explicit Error object parameter.
> > - This is a functional step towards transitioning the entire codebase
> >   to the new error-parameterized functions.
> > - Deliberately called in mutual exclusion from their counterparts,
> >   to prevent conflicts during the transition.
> > - New impls should preferentally use 'errp' variants of
> >   these methods, and existing impls incrementally converted.
> >   The variants without 'errp' are intended to be removed
> >   once all usage is converted.
> >
> > Signed-off-by: Arun Menon <armenon@redhat.com>
> > ---
> >  include/migration/vmstate.h | 11 ++++++++
> >  migration/vmstate.c         | 62
> > +++++++++++++++++++++++++++++++++++++++------
> >  2 files changed, 65 insertions(+), 8 deletions(-)
> >
> > diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> > index
> > 056781b1c21e737583f081594d9f88b32adfd674..53fa72c1bbde399be02c88fc8745fdbb79bfd7c8
> > 100644
> > --- a/include/migration/vmstate.h
> > +++ b/include/migration/vmstate.h
> > @@ -200,15 +200,26 @@ struct VMStateDescription {
> >       * exclusive. For this reason, also early_setup VMSDs are migrated in
> > a
> >       * QEMU_VM_SECTION_FULL section, while save_setup() data is migrated
> > in
> >       * a QEMU_VM_SECTION_START section.
> > +     *
> > +     * There are duplicate impls of the post/pre save/load hooks.
> > +     * New impls should preferentally use 'errp' variants of these
> > +     * methods and existing impls incrementally converted.
> > +     * The variants without 'errp' are intended to be removed
> > +     * once all usage is converted.
> >
> 
> It is not documented, but I think all the callbacks return value should be
> 0 on success, <0 on error with -value an error number from errno.h. Could
> you document it?
Sure. I shall add it in the header file and also in main.rst
> 
> 
> >       */
> > +
> >      bool early_setup;
> >      int version_id;
> >      int minimum_version_id;
> >      MigrationPriority priority;
> >      int (*pre_load)(void *opaque);
> > +    int (*pre_load_errp)(void *opaque, Error **errp);
> >      int (*post_load)(void *opaque, int version_id);
> > +    int (*post_load_errp)(void *opaque, int version_id, Error **errp);
> >      int (*pre_save)(void *opaque);
> > +    int (*pre_save_errp)(void *opaque, Error **errp);
> >      int (*post_save)(void *opaque);
> > +    int (*post_save_errp)(void *opaque, Error **errp);
> >      bool (*needed)(void *opaque);
> >      bool (*dev_unplug_pending)(void *opaque);
> >
> 
> You will also need to update docs/devel/migration/main.rst to reflect the
> new callbacks
Yes
> 
> 
> >
> > diff --git a/migration/vmstate.c b/migration/vmstate.c
> > index
> > bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb..e427ef49b2b1991b0a3cdb14d641c197e00014b0
> > 100644
> > --- a/migration/vmstate.c
> > +++ b/migration/vmstate.c
> > @@ -152,7 +152,16 @@ int vmstate_load_state(QEMUFile *f, const
> > VMStateDescription *vmsd,
> >          trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
> >          return -EINVAL;
> >      }
> > -    if (vmsd->pre_load) {
> > +    if (vmsd->pre_load_errp) {
> > +        ret = vmsd->pre_load_errp(opaque, errp);
> > +        if (ret) {
> > +            error_prepend(errp, "VM pre load failed for: '%s', "
> > +                          "version_id: '%d', minimum version_id: '%d', "
> > +                          "ret: %d: ", vmsd->name, vmsd->version_id,
> > +                          vmsd->minimum_version_id, ret);
> >
> 
> (but we don't have error_prepend_errno, ok)
> 
> 
> > +            return ret;
> 
> +        }
> > +    } else if (vmsd->pre_load) {
> >          ret = vmsd->pre_load(opaque);
> >          if (ret) {
> >              error_setg(errp, "VM pre load failed for: '%s', "
> > @@ -236,7 +245,14 @@ int vmstate_load_state(QEMUFile *f, const
> > VMStateDescription *vmsd,
> >          qemu_file_set_error(f, ret);
> >          return ret;
> >      }
> > -    if (vmsd->post_load) {
> > +    if (vmsd->post_load_errp) {
> > +        ret = vmsd->post_load_errp(opaque, version_id, errp);
> > +        if (ret < 0) {
> > +            error_prepend(errp, "VM Post load failed for: %s, version_id:
> > %d, "
> > +                          "minimum_version: %d, ret: %d: ", vmsd->name,
> > +                          vmsd->version_id, vmsd->minimum_version_id,
> > ret);
> > +        }
> > +    } else if (vmsd->post_load) {
> >          ret = vmsd->post_load(opaque, version_id);
> >          if (ret < 0) {
> >              error_setg(errp,
> > @@ -412,11 +428,19 @@ int vmstate_save_state_v(QEMUFile *f, const
> > VMStateDescription *vmsd,
> >                           void *opaque, JSONWriter *vmdesc, int
> > version_id, Error **errp)
> >  {
> >      int ret = 0;
> > +    Error *local_err = NULL;
> >      const VMStateField *field = vmsd->fields;
> >
> >      trace_vmstate_save_state_top(vmsd->name);
> >
> > -    if (vmsd->pre_save) {
> > +    if (vmsd->pre_save_errp) {
> > +        ret = vmsd->pre_save_errp(opaque, errp);
> > +        trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> > +        if (ret) {
> > +            error_prepend(errp, "pre-save failed: %s: ", vmsd->name);
> >
> 
> Here, it would be helpful to report "ret" too.
Sure, will add.
> 
> 
> > +            return ret;
> > +        }
> > +    } else if (vmsd->pre_save) {
> >
> 
> Imho, you should try to introduce a new helper function to call the
> implemented callback appropriately and handle the non-errp case:
> 
> int the_callback(vmsd,.. **errp)
> {
>   ERRP_GUARD(); // mostly for consistency
> 
>   if (vmsd->the_callback_errp) {
>    return vmsd->the_callback_errp(args.., errp);
>   } else if (vmsd->the_callback) {
>     ret =vmsd->the_callback(args...);
>     error_setg_errno(-ret, "the callback failed...")
>     return ret;
>   }
> 
>   return 0;
> }
> 
> This should make it a bit easier to deal with.
Yes, will do.
> 
>          ret = vmsd->pre_save(opaque);
> >          trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
> >          if (ret) {
> > @@ -524,10 +548,22 @@ int vmstate_save_state_v(QEMUFile *f, const
> > VMStateDescription *vmsd,
> >                  }
> >
> >                  if (ret) {
> > -                    error_setg(errp, "Save of field %s/%s failed",
> > -                                vmsd->name, field->name);
> > -                    if (vmsd->post_save) {
> > -                        vmsd->post_save(opaque);
> > +                    if (*errp == NULL) {
> > +                        error_setg(errp, "Save of field %s/%s failed",
> > +                                   vmsd->name, field->name);
> > +                    }
> > +                    if (vmsd->post_save_errp) {
> > +                        int ps_ret = vmsd->post_save_errp(opaque,
> > &local_err);
> > +                        if (ps_ret < 0) {
> > +                            error_free_or_abort(errp);
> > +                            error_propagate(errp, local_err);
> > +                            ret = ps_ret;
> > +                        }
> > +                    } else if (vmsd->post_save) {
> > +                        int ps_ret = vmsd->post_save(opaque);
> >
> 
> It's a bit odd how post_save() is being used here. It could be worth to
> document that it is called regardless of success of migration in callback
> doc.
I think it is present in the documentation.

+  This function is called after we save the state of one device
+  (even upon failure, unless the call to pre_save returned an error).

> 
> Imho, the function vmstate_save_state_v() should be refactored to call
> pre_save() and post_save() and call an internal function in between. It
> will also help to shrink the function a bit.
Possible. I shall give it a try. But just by adding pre-save and post-save
wrapper functions makes the code lot more readable.
> 
> 
> > +                        if (ps_ret < 0) {
> > +                            ret = ps_ret;
> > +                        }
> >                      }
> >                      return ret;
> >                  }
> > @@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const
> > VMStateDescription *vmsd,
> >
> >      ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
> >
> > -    if (vmsd->post_save) {
> > +    if (vmsd->post_save_errp) {
> > +        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
> > +        if (!ret && ps_ret) {
> > +            ret = ps_ret;
> > +            error_propagate(errp, local_err);
> > +        } else if (ret && ps_ret) {
> > +            error_free_or_abort(errp);
> > +            error_propagate(errp, local_err);
> > +            ret = ps_ret;
> > +        }
> > +    } else if (vmsd->post_save) {
> >          int ps_ret = vmsd->post_save(opaque);
> >          if (!ret && ps_ret) {
> >              ret = ps_ret;
> >
> > --
> > 2.50.0
> >
> >

Regards,
Arun

Re: [PATCH v7 01/24] migration: push Error **errp into vmstate_subsection_load()

[Arun Menon]

Hi Marc-André,

Thanks for the review.

On Mon, Jul 28, 2025 at 12:44:53PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 5:46 PM Marc-André Lureau <
> marcandre.lureau@redhat.com> wrote:
> 
> >
> >
> > On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
> >
> >> This is an incremental step in converting vmstate loading
> >> code to report error via Error objects instead of directly
> >> printing it to console/monitor.
> >> It is ensured that vmstate_subsection_load() must report an error
> >> in errp, in case of failure.
> >>
> >> Signed-off-by: Arun Menon <armenon@redhat.com>
> >> ---
> >>  migration/vmstate.c | 11 ++++++++---
> >>  1 file changed, 8 insertions(+), 3 deletions(-)
> >>
> >> diff --git a/migration/vmstate.c b/migration/vmstate.c
> >> index
> >> 5feaa3244d259874f03048326b2497e7db32e47c..aeffeafaa4fa7582076a4f2747906ddf9aca891b
> >> 100644
> >> --- a/migration/vmstate.c
> >> +++ b/migration/vmstate.c
> >> @@ -25,7 +25,7 @@ static int vmstate_subsection_save(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>                                     void *opaque, JSONWriter *vmdesc,
> >>                                     Error **errp);
> >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> >> *vmsd,
> >> -                                   void *opaque);
> >> +                                   void *opaque, Error **errp);
> >>
> >>  /* Whether this field should exist for either save or load the VM? */
> >>  static bool
> >> @@ -225,7 +225,7 @@ int vmstate_load_state(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          field++;
> >>      }
> >>      assert(field->flags == VMS_END);
> >> -    ret = vmstate_subsection_load(f, vmsd, opaque);
> >> +    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> >>      if (ret != 0) {
> >>          qemu_file_set_error(f, ret);
> >>          return ret;
> >> @@ -566,7 +566,7 @@ vmstate_get_subsection(const VMStateDescription *
> >> const *sub,
> >>  }
> >>
> >>  static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription
> >> *vmsd,
> >> -                                   void *opaque)
> >> +                                   void *opaque, Error **errp)
> >>  {
> >>      trace_vmstate_subsection_load(vmsd->name);
> >>
> >> @@ -598,6 +598,8 @@ static int vmstate_subsection_load(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
> >>          if (sub_vmsd == NULL) {
> >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> >> "(lookup)");
> >> +            error_setg(errp, "VM subsection '%s' in '%s' does not exist",
> >> +                       idstr, vmsd->name);
> >>              return -ENOENT;
> >>          }
> >>          qemu_file_skip(f, 1); /* subsection */
> >> @@ -608,6 +610,9 @@ static int vmstate_subsection_load(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>          ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> >>          if (ret) {
> >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> >> "(child)");
> >> +            error_setg(errp,
> >> +                       "Loading VM subsection '%s' in '%s' failed : %d",
> >>
> >
> > extra space before ":"
> >
> > other than that
> > Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> 
> Actually, almost systematically when you introduce an extra **errp
> argument, you should ERRP_GUARD() in the function (see include/qapi/error.h
> doc). Was this discussed before? Can you update the following patches too?

I see. Thanks. I shall add ERRP_GUARD() whenever errp is dereferenced or used with
error_prepend().

> 
> 
> >
> >> +                       idstr, vmsd->name, ret);
> >>              return ret;
> >>          }
> >>      }
> >>
> >> --
> >> 2.50.0
> >>
> >>

Regards,
Arun

Re: [PATCH v7 02/24] migration: push Error **errp into vmstate_load_state()

[Arun Menon]

Hi Marc-André,
Thank you for the review.

On Mon, Jul 28, 2025 at 02:14:05PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 5:48 PM Marc-André Lureau <
> marcandre.lureau@redhat.com> wrote:
> 
> >
> >
> > On Fri, Jul 25, 2025 at 4:19 PM Arun Menon <armenon@redhat.com> wrote:
> >
> >> This is an incremental step in converting vmstate loading
> >> code to report error via Error objects instead of directly
> >> printing it to console/monitor.
> >> It is ensured that vmstate_load_state() must report an error
> >> in errp, in case of failure.
> >>
> >> Signed-off-by: Arun Menon <armenon@redhat.com>
> >>
> >
> > Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> 
> Actually, there is a general issue with this patch and following patches.
> 
> Whenever it replaces error_report() with error_setg*(), all the callers
> should be checked or updated to report the error instead..
> 
> 
> >
> >
> >> ---
> >>  hw/display/virtio-gpu.c     |  2 +-
> >>  hw/pci/pci.c                |  2 +-
> >>  hw/s390x/virtio-ccw.c       |  2 +-
> >>  hw/scsi/spapr_vscsi.c       |  2 +-
> >>  hw/vfio/pci.c               |  2 +-
> >>  hw/virtio/virtio-mmio.c     |  2 +-
> >>  hw/virtio/virtio-pci.c      |  2 +-
> >>  hw/virtio/virtio.c          |  4 ++--
> >>  include/migration/vmstate.h |  2 +-
> >>  migration/cpr.c             |  4 ++--
> >>  migration/savevm.c          |  6 ++++--
> >>  migration/vmstate-types.c   | 10 ++++-----
> >>  migration/vmstate.c         | 49
> >> ++++++++++++++++++++++++++++-----------------
> >>  tests/unit/test-vmstate.c   | 18 ++++++++---------
> >>  ui/vdagent.c                |  2 +-
> >>  15 files changed, 62 insertions(+), 47 deletions(-)
> >>
> >> diff --git a/hw/display/virtio-gpu.c b/hw/display/virtio-gpu.c
> >> index
> >> 0a1a625b0ea6cf26cb0d799171a57ed3d3ab2442..5d2ca8d8b864350133a674802d7316abd379591c
> >> 100644
> >> --- a/hw/display/virtio-gpu.c
> >> +++ b/hw/display/virtio-gpu.c
> >> @@ -1343,7 +1343,7 @@ 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);
> >> +    vmstate_load_state(f, &vmstate_virtio_gpu_scanouts, g, 1, NULL);
> >>
> >
> So all the added NULL arguments should probably be &error_warn (or
> &error_fatal) instead.
Sure, will do.
> 
> 
> 
> >>      return 0;
> >>  }
> >> diff --git a/hw/pci/pci.c b/hw/pci/pci.c
> >> index
> >> c70b5ceebaf1f2b10768bd030526cbb518da2b8d..2ab5d30bb3c319ac1c7bfc9a2acf6a2b38082066
> >> 100644
> >> --- a/hw/pci/pci.c
> >> +++ b/hw/pci/pci.c
> >> @@ -934,7 +934,7 @@ void pci_device_save(PCIDevice *s, QEMUFile *f)
> >>  int pci_device_load(PCIDevice *s, QEMUFile *f)
> >>  {
> >>      int ret;
> >> -    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id);
> >> +    ret = vmstate_load_state(f, &vmstate_pci_device, s, s->version_id,
> >> NULL);
> >>      /* Restore the interrupt status bit. */
> >>      pci_update_irq_status(s);
> >>      return ret;
> >> diff --git a/hw/s390x/virtio-ccw.c b/hw/s390x/virtio-ccw.c
> >> index
> >> d2f85b39f30f7fc82e0c600144c0a958e1269b2c..2f6feff2b0a22d7d7f6aecfd7e7870d8362f1a73
> >> 100644
> >> --- a/hw/s390x/virtio-ccw.c
> >> +++ b/hw/s390x/virtio-ccw.c
> >> @@ -1136,7 +1136,7 @@ static void virtio_ccw_save_config(DeviceState *d,
> >> QEMUFile *f)
> >>  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);
> >> +    return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1, NULL);
> >>  }
> >>
> >>  static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
> >> diff --git a/hw/scsi/spapr_vscsi.c b/hw/scsi/spapr_vscsi.c
> >> index
> >> 20f70fb2729de78b9636a6b8c869695dab4f8902..573fdea668536b464bca11f001e9e0288e781493
> >> 100644
> >> --- a/hw/scsi/spapr_vscsi.c
> >> +++ b/hw/scsi/spapr_vscsi.c
> >> @@ -648,7 +648,7 @@ static void *vscsi_load_request(QEMUFile *f,
> >> SCSIRequest *sreq)
> >>      assert(!req->active);
> >>
> >>      memset(req, 0, sizeof(*req));
> >> -    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1);
> >> +    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1, NULL);
> >>      if (rc) {
> >>          fprintf(stderr, "VSCSI: failed loading request tag#%u\n",
> >> sreq->tag);
> >>          return NULL;
> >> diff --git a/hw/vfio/pci.c b/hw/vfio/pci.c
> >> index
> >> e72d514a4cb91946f7c79332492bf5d709c308f2..498bbb96e97df50af5fc906fa00d4436c1edc05f
> >> 100644
> >> --- a/hw/vfio/pci.c
> >> +++ b/hw/vfio/pci.c
> >> @@ -2797,7 +2797,7 @@ static int vfio_pci_load_config(VFIODevice
> >> *vbasedev, QEMUFile *f)
> >>          old_addr[bar] = pdev->io_regions[bar].addr;
> >>      }
> >>
> >> -    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1);
> >> +    ret = vmstate_load_state(f, &vmstate_vfio_pci_config, vdev, 1, NULL);
> >>      if (ret) {
> >>          return ret;
> >>      }
> >> diff --git a/hw/virtio/virtio-mmio.c b/hw/virtio/virtio-mmio.c
> >> index
> >> 532c67107ba1d2978a76cf49f9cdc1de1dea3e11..9058b1563462d4464dcba799643a583c93fb5683
> >> 100644
> >> --- a/hw/virtio/virtio-mmio.c
> >> +++ b/hw/virtio/virtio-mmio.c
> >> @@ -619,7 +619,7 @@ static int virtio_mmio_load_extra_state(DeviceState
> >> *opaque, QEMUFile *f)
> >>  {
> >>      VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
> >>
> >> -    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1);
> >> +    return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1, NULL);
> >>  }
> >>
> >>  static bool virtio_mmio_has_extra_state(DeviceState *opaque)
> >> diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
> >> index
> >> 767216d795998708f5716a23ae16c79cd90ff489..f8b52a611e56c22d844fd4cae3619da4f2686d03
> >> 100644
> >> --- a/hw/virtio/virtio-pci.c
> >> +++ b/hw/virtio/virtio-pci.c
> >> @@ -161,7 +161,7 @@ static int virtio_pci_load_extra_state(DeviceState
> >> *d, QEMUFile *f)
> >>  {
> >>      VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
> >>
> >> -    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1);
> >> +    return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1, NULL);
> >>  }
> >>
> >>  static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
> >> diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
> >> index
> >> 2ab1d20769495ea39445b87e3673b076ad172510..d5698b062a1e95437f6113f41136e90ae06f1974
> >> 100644
> >> --- a/hw/virtio/virtio.c
> >> +++ b/hw/virtio/virtio.c
> >> @@ -3317,14 +3317,14 @@ virtio_load(VirtIODevice *vdev, QEMUFile *f, int
> >> version_id)
> >>      }
> >>
> >>      if (vdc->vmsd) {
> >> -        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id);
> >> +        ret = vmstate_load_state(f, vdc->vmsd, vdev, version_id, NULL);
> >>          if (ret) {
> >>              return ret;
> >>          }
> >>      }
> >>
> >>      /* Subsections */
> >> -    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
> >> +    ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1, NULL);
> >>      if (ret) {
> >>          return ret;
> >>      }
> >> diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h
> >> index
> >> 1ff7bd9ac425ba67cd5ca7ad97bcf570f9e19abe..056781b1c21e737583f081594d9f88b32adfd674
> >> 100644
> >> --- a/include/migration/vmstate.h
> >> +++ b/include/migration/vmstate.h
> >> @@ -1196,7 +1196,7 @@ extern const VMStateInfo vmstate_info_qlist;
> >>      }
> >>
> >>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> >> -                       void *opaque, int version_id);
> >> +                       void *opaque, int version_id, Error **errp);
> >>  int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
> >>                         void *opaque, JSONWriter *vmdesc);
> >>  int vmstate_save_state_with_err(QEMUFile *f, const VMStateDescription
> >> *vmsd,
> >> diff --git a/migration/cpr.c b/migration/cpr.c
> >> index
> >> 42ad0b0d500e5de57faf0c6517e216b2d1c0cacf..9569c3f76bf8714def6406ae24f7fbc5afa4e793
> >> 100644
> >> --- a/migration/cpr.c
> >> +++ b/migration/cpr.c
> >> @@ -233,9 +233,9 @@ int cpr_state_load(MigrationChannel *channel, Error
> >> **errp)
> >>          return -ENOTSUP;
> >>      }
> >>
> >> -    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1);
> >> +    ret = vmstate_load_state(f, &vmstate_cpr_state, &cpr_state, 1, errp);
> >>      if (ret) {
> >> -        error_setg(errp, "vmstate_load_state error %d", ret);
> >> +        error_prepend(errp, "vmstate_load_state error %d: ", ret);
> >>          qemu_fclose(f);
> >>          return ret;
> >>      }
> >> diff --git a/migration/savevm.c b/migration/savevm.c
> >> index
> >> fabbeb296ae987d0c06ba6dafda63720205fecfd..ab947620f724874f325fb9fb59bef50b7c16fb51
> >> 100644
> >> --- a/migration/savevm.c
> >> +++ b/migration/savevm.c
> >> @@ -969,7 +969,8 @@ static int vmstate_load(QEMUFile *f, SaveStateEntry
> >> *se)
> >>      if (!se->vmsd) {         /* Old style */
> >>          return se->ops->load_state(f, se->opaque, se->load_version_id);
> >>      }
> >> -    return vmstate_load_state(f, se->vmsd, se->opaque,
> >> se->load_version_id);
> >> +    return vmstate_load_state(f, se->vmsd, se->opaque,
> >> se->load_version_id,
> >> +                              NULL);
> >>  }
> >>
> >>  static void vmstate_save_old_style(QEMUFile *f, SaveStateEntry *se,
> >> @@ -2839,7 +2840,8 @@ static int qemu_loadvm_state_header(QEMUFile *f)
> >>              error_report("Configuration section missing");
> >>              return -EINVAL;
> >>          }
> >> -        ret = vmstate_load_state(f, &vmstate_configuration,
> >> &savevm_state, 0);
> >> +        ret = vmstate_load_state(f, &vmstate_configuration,
> >> &savevm_state, 0,
> >> +                                 NULL);
> >>
> >>          if (ret) {
> >>              return ret;
> >> diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c
> >> index
> >> 741a588b7e18c6d37724b08a0101edc8bc74a0a5..1c5b76e1dd198030847971bc35637867c9d54fc0
> >> 100644
> >> --- a/migration/vmstate-types.c
> >> +++ b/migration/vmstate-types.c
> >> @@ -549,7 +549,7 @@ static int get_tmp(QEMUFile *f, void *pv, size_t size,
> >>
> >>      /* Writes the parent field which is at the start of the tmp */
> >>      *(void **)tmp = pv;
> >> -    ret = vmstate_load_state(f, vmsd, tmp, version_id);
> >> +    ret = vmstate_load_state(f, vmsd, tmp, version_id, NULL);
> >>      g_free(tmp);
> >>      return ret;
> >>  }
> >> @@ -649,7 +649,7 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t
> >> unused_size,
> >>
> >>      while (qemu_get_byte(f)) {
> >>          elm = g_malloc(size);
> >> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
> >> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
> >>          if (ret) {
> >>              return ret;
> >>          }
> >> @@ -803,7 +803,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
> >> unused_size,
> >>              key = (void *)(uintptr_t)qemu_get_be64(f);
> >>          } else {
> >>              key = g_malloc0(key_size);
> >> -            ret = vmstate_load_state(f, key_vmsd, key, version_id);
> >> +            ret = vmstate_load_state(f, key_vmsd, key, version_id, NULL);
> >>              if (ret) {
> >>                  error_report("%s : failed to load %s (%d)",
> >>                               field->name, key_vmsd->name, ret);
> >> @@ -811,7 +811,7 @@ static int get_gtree(QEMUFile *f, void *pv, size_t
> >> unused_size,
> >>              }
> >>          }
> >>          val = g_malloc0(val_size);
> >> -        ret = vmstate_load_state(f, val_vmsd, val, version_id);
> >> +        ret = vmstate_load_state(f, val_vmsd, val, version_id, NULL);
> >>          if (ret) {
> >>              error_report("%s : failed to load %s (%d)",
> >>                           field->name, val_vmsd->name, ret);
> >> @@ -892,7 +892,7 @@ static int get_qlist(QEMUFile *f, void *pv, size_t
> >> unused_size,
> >>
> >>      while (qemu_get_byte(f)) {
> >>          elm = g_malloc(size);
> >> -        ret = vmstate_load_state(f, vmsd, elm, version_id);
> >> +        ret = vmstate_load_state(f, vmsd, elm, version_id, NULL);
> >>          if (ret) {
> >>              error_report("%s: failed to load %s (%d)", field->name,
> >>                           vmsd->name, ret);
> >> diff --git a/migration/vmstate.c b/migration/vmstate.c
> >> index
> >> aeffeafaa4fa7582076a4f2747906ddf9aca891b..bb5e9bf38d6ee7619ceb3e9da29209581c3c12eb
> >> 100644
> >> --- a/migration/vmstate.c
> >> +++ b/migration/vmstate.c
> >> @@ -132,29 +132,33 @@ static void vmstate_handle_alloc(void *ptr, const
> >> VMStateField *field,
> >>  }
> >>
> >>  int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> >> -                       void *opaque, int version_id)
> >> +                       void *opaque, int version_id, Error **errp)
> >>  {
> >>      const VMStateField *field = vmsd->fields;
> >>      int ret = 0;
> >>
> >>      trace_vmstate_load_state(vmsd->name, version_id);
> >>      if (version_id > vmsd->version_id) {
> >> -        error_report("%s: incoming version_id %d is too new "
> >> -                     "for local version_id %d",
> >> -                     vmsd->name, version_id, vmsd->version_id);
> >> +        error_setg(errp, "%s: incoming version_id %d is too new "
> >> +                   "for local version_id %d",
> >> +                   vmsd->name, version_id, vmsd->version_id);
> >>          trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
> >>          return -EINVAL;
> >>      }
> >>      if  (version_id < vmsd->minimum_version_id) {
> >> -        error_report("%s: incoming version_id %d is too old "
> >> -                     "for local minimum version_id  %d",
> >> -                     vmsd->name, version_id, vmsd->minimum_version_id);
> >> +        error_setg(errp, "%s: incoming version_id %d is too old "
> >> +                   "for local minimum version_id  %d",
> >> +                   vmsd->name, version_id, vmsd->minimum_version_id);
> >>          trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
> >>          return -EINVAL;
> >>      }
> >>      if (vmsd->pre_load) {
> >>          ret = vmsd->pre_load(opaque);
> >>          if (ret) {
> >> +            error_setg(errp, "VM pre load failed for: '%s', "
> >> +                       "version_id: '%d', minimum version_id: '%d', ret:
> >> %d",
> >> +                       vmsd->name, vmsd->version_id,
> >> vmsd->minimum_version_id,
> >> +                       ret);
> >>              return ret;
> >>          }
> >>      }
> >> @@ -192,10 +196,12 @@ int vmstate_load_state(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>
> >>                  if (inner_field->flags & VMS_STRUCT) {
> >>                      ret = vmstate_load_state(f, inner_field->vmsd,
> >> curr_elem,
> >> -
> >>  inner_field->vmsd->version_id);
> >> +
> >>  inner_field->vmsd->version_id,
> >> +                                             errp);
> >>                  } else if (inner_field->flags & VMS_VSTRUCT) {
> >>                      ret = vmstate_load_state(f, inner_field->vmsd,
> >> curr_elem,
> >> -
> >>  inner_field->struct_version_id);
> >> +
> >>  inner_field->struct_version_id,
> >> +                                             errp);
> >>                  } else {
> >>                      ret = inner_field->info->get(f, curr_elem, size,
> >>                                                   inner_field);
> >> @@ -211,27 +217,34 @@ int vmstate_load_state(QEMUFile *f, const
> >> VMStateDescription *vmsd,
> >>                  }
> >>                  if (ret < 0) {
> >>                      qemu_file_set_error(f, ret);
> >> -                    error_report("Failed to load %s:%s", vmsd->name,
> >> -                                 field->name);
> >> +                    error_prepend(errp, "Failed to load %s:%s
> >> version_id: %d: ",
> >> +                                  vmsd->name, field->name,
> >> vmsd->version_id);
> >>                      trace_vmstate_load_field_error(field->name, ret);
> >>                      return ret;
> >>                  }
> >>              }
> >>          } else if (field->flags & VMS_MUST_EXIST) {
> >> -            error_report("Input validation failed: %s/%s",
> >> -                         vmsd->name, field->name);
> >> +            error_setg(errp, "Input validation failed: %s/%s version_id:
> >> %d",
> >> +                       vmsd->name, field->name, vmsd->version_id);
> >>              return -1;
> >>          }
> >>          field++;
> >>      }
> >>      assert(field->flags == VMS_END);
> >> -    ret = vmstate_subsection_load(f, vmsd, opaque, NULL);
> >> +    ret = vmstate_subsection_load(f, vmsd, opaque, errp);
> >>      if (ret != 0) {
> >>          qemu_file_set_error(f, ret);
> >>          return ret;
> >>      }
> >>      if (vmsd->post_load) {
> >>          ret = vmsd->post_load(opaque, version_id);
> >> +        if (ret < 0) {
> >> +            error_setg(errp,
> >> +                       "VM Post load failed for: %s, version_id: %d, "
> >> +                       "minimum_version: %d, ret: %d",
> >> +                       vmsd->name, vmsd->version_id,
> >> vmsd->minimum_version_id,
> >> +                       ret);
> >> +        }
> >>      }
> >>      trace_vmstate_load_state_end(vmsd->name, "end", ret);
> >>      return ret;
> >> @@ -607,12 +620,12 @@ static int vmstate_subsection_load(QEMUFile *f,
> >> const VMStateDescription *vmsd,
> >>          qemu_file_skip(f, len); /* idstr */
> >>          version_id = qemu_get_be32(f);
> >>
> >> -        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
> >> +        ret = vmstate_load_state(f, sub_vmsd, opaque, version_id, errp);
> >>          if (ret) {
> >>              trace_vmstate_subsection_load_bad(vmsd->name, idstr,
> >> "(child)");
> >> -            error_setg(errp,
> >> -                       "Loading VM subsection '%s' in '%s' failed : %d",
> >> -                       idstr, vmsd->name, ret);
> >> +            error_prepend(errp,
> >> +                          "Loading VM subsection '%s' in '%s' failed:
> >> '%d': ",
> >> +                          idstr, vmsd->name, ret);
> >>              return ret;
> >>          }
> >>      }
> >> diff --git a/tests/unit/test-vmstate.c b/tests/unit/test-vmstate.c
> >> index
> >> 63f28f26f45691a70936d33e7341d16477a3471f..ca5e0ba1e3e5e2bb0a1ce39143a292f2c6f9420a
> >> 100644
> >> --- a/tests/unit/test-vmstate.c
> >> +++ b/tests/unit/test-vmstate.c
> >> @@ -114,7 +114,7 @@ static int load_vmstate_one(const VMStateDescription
> >> *desc, void *obj,
> >>      qemu_fclose(f);
> >>
> >>      f = open_test_file(false);
> >> -    ret = vmstate_load_state(f, desc, obj, version);
> >> +    ret = vmstate_load_state(f, desc, obj, version, NULL);
> >>      if (ret) {
> >>          g_assert(qemu_file_get_error(f));
> >>      } else{
> >> @@ -365,7 +365,7 @@ static void test_load_v1(void)
> >>
> >>      QEMUFile *loading = open_test_file(false);
> >>      TestStruct obj = { .b = 200, .e = 500, .f = 600 };
> >> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 1);
> >> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 1, NULL);
> >>      g_assert(!qemu_file_get_error(loading));
> >>      g_assert_cmpint(obj.a, ==, 10);
> >>      g_assert_cmpint(obj.b, ==, 200);
> >> @@ -391,7 +391,7 @@ static void test_load_v2(void)
> >>
> >>      QEMUFile *loading = open_test_file(false);
> >>      TestStruct obj;
> >> -    vmstate_load_state(loading, &vmstate_versioned, &obj, 2);
> >> +    vmstate_load_state(loading, &vmstate_versioned, &obj, 2, NULL);
> >>      g_assert_cmpint(obj.a, ==, 10);
> >>      g_assert_cmpint(obj.b, ==, 20);
> >>      g_assert_cmpint(obj.c, ==, 30);
> >> @@ -480,7 +480,7 @@ static void test_load_noskip(void)
> >>
> >>      QEMUFile *loading = open_test_file(false);
> >>      TestStruct obj = { .skip_c_e = false };
> >> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
> >> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
> >>      g_assert(!qemu_file_get_error(loading));
> >>      g_assert_cmpint(obj.a, ==, 10);
> >>      g_assert_cmpint(obj.b, ==, 20);
> >> @@ -504,7 +504,7 @@ static void test_load_skip(void)
> >>
> >>      QEMUFile *loading = open_test_file(false);
> >>      TestStruct obj = { .skip_c_e = true, .c = 300, .e = 500 };
> >> -    vmstate_load_state(loading, &vmstate_skipping, &obj, 2);
> >> +    vmstate_load_state(loading, &vmstate_skipping, &obj, 2, NULL);
> >>      g_assert(!qemu_file_get_error(loading));
> >>      g_assert_cmpint(obj.a, ==, 10);
> >>      g_assert_cmpint(obj.b, ==, 20);
> >> @@ -773,7 +773,7 @@ static void test_load_q(void)
> >>      TestQtailq tgt;
> >>
> >>      QTAILQ_INIT(&tgt.q);
> >> -    vmstate_load_state(fload, &vmstate_q, &tgt, 1);
> >> +    vmstate_load_state(fload, &vmstate_q, &tgt, 1, NULL);
> >>      char eof = qemu_get_byte(fload);
> >>      g_assert(!qemu_file_get_error(fload));
> >>      g_assert_cmpint(tgt.i16, ==, obj_q.i16);
> >> @@ -1127,7 +1127,7 @@ static void test_gtree_load_domain(void)
> >>
> >>      fload = open_test_file(false);
> >>
> >> -    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1);
> >> +    vmstate_load_state(fload, &vmstate_domain, dest_domain, 1, NULL);
> >>      eof = qemu_get_byte(fload);
> >>      g_assert(!qemu_file_get_error(fload));
> >>      g_assert_cmpint(orig_domain->id, ==, dest_domain->id);
> >> @@ -1241,7 +1241,7 @@ static void test_gtree_load_iommu(void)
> >>      qemu_fclose(fsave);
> >>
> >>      fload = open_test_file(false);
> >> -    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1);
> >> +    vmstate_load_state(fload, &vmstate_iommu, dest_iommu, 1, NULL);
> >>      eof = qemu_get_byte(fload);
> >>      g_assert(!qemu_file_get_error(fload));
> >>      g_assert_cmpint(orig_iommu->id, ==, dest_iommu->id);
> >> @@ -1376,7 +1376,7 @@ static void test_load_qlist(void)
> >>      qemu_fclose(fsave);
> >>
> >>      fload = open_test_file(false);
> >> -    vmstate_load_state(fload, &vmstate_container, dest_container, 1);
> >> +    vmstate_load_state(fload, &vmstate_container, dest_container, 1,
> >> NULL);
> >>      eof = qemu_get_byte(fload);
> >>      g_assert(!qemu_file_get_error(fload));
> >>      g_assert_cmpint(eof, ==, QEMU_VM_EOF);
> >> diff --git a/ui/vdagent.c b/ui/vdagent.c
> >> index
> >> c0746fe5b168fdc7aeb4866de2ba0c3387566649..83457dee0767433ad0778b37b41b9c673a0e1860
> >> 100644
> >> --- a/ui/vdagent.c
> >> +++ b/ui/vdagent.c
> >> @@ -1008,7 +1008,7 @@ static int get_cbinfo(QEMUFile *f, void *pv, size_t
> >> size,
> >>
> >>      vdagent_clipboard_peer_register(vd);
> >>
> >> -    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0);
> >> +    ret = vmstate_load_state(f, &vmstate_cbinfo_array, &cbinfo, 0, NULL);
> >>      if (ret) {
> >>          return ret;
> >>      }
> >>
> >> --
> >> 2.50.0
> >>
> >>
Regards,
Arun

Re: [PATCH v7 08/24] migration: make loadvm_postcopy_handle_resume() void

[Arun Menon]

Hi Marc-André,
Thanks for the review.

On Mon, Jul 28, 2025 at 02:25:26PM +0400, Marc-André Lureau wrote:
> Hi
> 
> On Fri, Jul 25, 2025 at 4:20 PM Arun Menon <armenon@redhat.com> wrote:
> 
> > This is an incremental step in converting vmstate loading
> > code to report error via Error objects instead of directly
> > printing it to console/monitor.
> >
> > Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
> > Signed-off-by: Arun Menon <armenon@redhat.com>
> > ---
> >  migration/savevm.c | 11 +++++------
> >  1 file changed, 5 insertions(+), 6 deletions(-)
> >
> > diff --git a/migration/savevm.c b/migration/savevm.c
> > index
> > d8f5f1966fda831899596173f20fbef25d78829d..ad96da3651b89023e4b70ffeecab46d176bae6f5
> > 100644
> > --- a/migration/savevm.c
> > +++ b/migration/savevm.c
> > @@ -2334,12 +2334,12 @@ static void
> > migrate_send_rp_req_pages_pending(MigrationIncomingState *mis)
> >      }
> >  }
> >
> > -static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
> > +static void loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
> >  {
> >      if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
> > -        error_report("%s: illegal resume received", __func__);
> > +        warn_report("%s: illegal resume received", __func__);
> >
> 
> Could you add a comment to the commit message to explain why this somewhat
> unrelated change? thanks
Sure, will do.
> 
> 
> >          /* Don't fail the load, only for this. */
> > -        return 0;
> > +        return;
> >      }
> >
> >      /*
> > @@ -2391,8 +2391,6 @@ static int
> > loadvm_postcopy_handle_resume(MigrationIncomingState *mis)
> >          /* Kick the fast ram load thread too */
> >          qemu_sem_post(&mis->postcopy_pause_sem_fast_load);
> >      }
> > -
> > -    return 0;
> >  }
> >
> >  /**
> > @@ -2627,7 +2625,8 @@ static int loadvm_process_command(QEMUFile *f)
> >          return loadvm_postcopy_ram_handle_discard(mis, len);
> >
> >      case MIG_CMD_POSTCOPY_RESUME:
> > -        return loadvm_postcopy_handle_resume(mis);
> > +        loadvm_postcopy_handle_resume(mis);
> > +        return 0;
> >
> >      case MIG_CMD_RECV_BITMAP:
> >          return loadvm_handle_recv_bitmap(mis, len);
> >
> > --
> > 2.50.0
> >
> >
Regards,
Arun

Re: [PATCH v7 23/24] migration: Add error-parameterized function variants in VMSD struct

[Akihiko Odaki]

On 2025/07/28 19:54, Arun Menon wrote:
>>
>>> +                            error_free_or_abort(errp);
>>> +                            error_propagate(errp, local_err);
>>> +                            ret = ps_ret;
>>> +                        }
>>> +                    } else if (vmsd->post_save) {
>>> +                        int ps_ret = vmsd->post_save(opaque);
>>> +                        if (ps_ret < 0) {
>>> +                            ret = ps_ret;
>>> +                        }
>>>                        }
>>>                        return ret;
>>>                    }
>>> @@ -554,7 +590,17 @@ int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
>>>        ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc, errp);
>>> -    if (vmsd->post_save) {
>>> +    if (vmsd->post_save_errp) {
>>> +        int ps_ret = vmsd->post_save_errp(opaque, &local_err);
>>> +        if (!ret && ps_ret) {
>>> +            ret = ps_ret;
>>> +            error_propagate(errp, local_err);
>>> +        } else if (ret && ps_ret) {
>>> +            error_free_or_abort(errp);
>>> +            error_propagate(errp, local_err);
>>> +            ret = ps_ret;
>>> +        }
>>
>> Simpler:
>>
>> if (ps_ret) {
>>      if (ret) {
>>        error_free_or_abort(errp);
>>      }
>>      ret = ps_ret;
>>      error_propagate(errp, local_err);
>> }
>>
> Will do.
>>> +    } else if (vmsd->post_save) {
>>>            int ps_ret = vmsd->post_save(opaque);
>>>            if (!ret && ps_ret) {
>>>                ret = ps_ret;
>>
>> When there is a preceding error, this code still returns it and dismisses
>> the post_save() error although the other part of this function is changed to
>> propagate the error of post-save unconditionally. Please keep them
>> consistent.
> 
> I do feel that in the new implementation (post_save_errp), we should be dismissing
> the preceeding error and propagating the new error from post_save().
> Because, that way, it makes sense to run the post_save_errp() part even after encountering
> an error in the preceeding section (vmstate_subsection_save).

What to propagate to the caller shouldn't matter when running the 
post_save_errp() because the behavior is for the caller and not for the 
internal implementation of this function.

There are two requirements for this function:
1. The proceeding error should be passed to the caller
2. The proceeding error should not prevent calling post_save_errp()

Let's assume whether the proceeding error is dismissed or not affects 
both post_save_errp() and the caller. Under this assumption,
- if the proceeding error is dismissed, it will violate condition 1.
- if the proceeding error is not dismissed, it will violate condition 2.

So it is more reasonable to think that we are defining different 
handling methods for the caller and post_save_errp().

If error propagation for the caller still has an implication on the 
condition to run post_save_errp(), it means the meanings of the 
proceeding error for post_save_errp() and the caller are "different but 
somehow correlated". It sounds convoluted and I don't have an idea of 
such correlation.

I don't think there is a common answer for what error to propagate when 
there are several errors, so I see three options:
- propagate whatever error easier to do so
- somehow combine errors
   (languages that support exceptions often do this)
- make sure that no error will happen when there is a proceeding error
   by having two callbacks:
   - One callback that is called only when there is no proceeding error
     and can raise an error
   - Another that is always called but cannot raise an error

> 
> Not sure if I should change the old impl post_save to match post_save_errp,
> Or should I match the new impl with the old one.

The reasoning you provided applies for post_save() too, so I think they 
should have a consistent behavior if you stick to it.

That change is also better to be split into its own patch; by splitting 
it, you can ensure that, if this series causes a regression for TPM, 
bisect will tell what led to the regression: the return value 
propagation change or the addition of errp.

Regards,
Akihiko Odaki