Re: [PATCH v5 04/10] vfio: Use new Error** argument in vfio_save_setup()

[Cédric Le Goater]

On 5/13/24 15:21, Avihai Horon wrote:

On 06/05/2024 12:20, Cédric Le Goater wrote:

External email: Use caution opening links or attachments

Nit: change commit title prefix to vfio/migration (also in other patches that 
are closely related to vfio migration)

Plus, maybe change subject to "Add an Error** argument to vfio_migration_set_state() 
and adjust callers" as it's the main subject of the patch?

Add an Error** argument to vfio_migration_set_state() and adjust
callers, including vfio_save_setup(). The error will be propagated up
to qemu_savevm_state_setup() where the save_setup() handler is
executed.

Modify vfio_vmstate_change_prepare() and vfio_vmstate_change() to
store a reported error under the migration stream if a migration is in
progress.

Signed-off-by: Cédric Le Goater <c...@redhat.com>
---

  Changes in v5:

  - Replaced error_setg() by error_setg_errno() in vfio_migration_set_state()
  - Rebased on 20c64c8a51a4 ("migration: migration_file_set_error")

  hw/vfio/migration.c | 76 +++++++++++++++++++++++++--------------------
  1 file changed, 43 insertions(+), 33 deletions(-)

diff --git a/hw/vfio/migration.c b/hw/vfio/migration.c
index 
bf2fd0759ba6e4fb103cc5c1a43edb180a3d0de4..9b6375c949f7a8dca857ead2506855f63fa051e4
 100644
--- a/hw/vfio/migration.c
+++ b/hw/vfio/migration.c
@@ -82,7 +82,8 @@ static const char *mig_state_to_str(enum 
vfio_device_mig_state state)

  static int vfio_migration_set_state(VFIODevice *vbasedev,
                                      enum vfio_device_mig_state new_state,
-                                    enum vfio_device_mig_state recover_state)
+                                    enum vfio_device_mig_state recover_state,
+                                    Error **errp)
  {
      VFIOMigration *migration = vbasedev->migration;
      uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) +
@@ -102,25 +103,26 @@ static int vfio_migration_set_state(VFIODevice *vbasedev,
          ret = -errno;

          if (recover_state == VFIO_DEVICE_STATE_ERROR) {
-            error_report("%s: Failed setting device state to %s, err: %s. "
-                         "Recover state is ERROR. Resetting device",
-                         vbasedev->name, mig_state_to_str(new_state),
-                         strerror(errno));
+            error_setg_errno(errp, errno,
+                             "%s: Failed setting device state to %s. "
+                             "Recover state is ERROR. Resetting device",
+                             vbasedev->name, mig_state_to_str(new_state));

              goto reset_device;
          }

-        error_report(
-            "%s: Failed setting device state to %s, err: %s. Setting device in 
recover state %s",
-                     vbasedev->name, mig_state_to_str(new_state),
-                     strerror(errno), mig_state_to_str(recover_state));
+        error_setg_errno(errp, errno,
+                         "%s: Failed setting device state to %s. "
+                         "Setting device in recover state %s",
+                         vbasedev->name, mig_state_to_str(new_state),
+                         mig_state_to_str(recover_state));

          mig_state->device_state = recover_state;
          if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) {
              ret = -errno;
-            error_report(
-                "%s: Failed setting device in recover state, err: %s. Resetting 
device",
-                         vbasedev->name, strerror(errno));
+            error_setg_errno(errp, errno,
+                             "%s: Failed setting device in recover state. "
+                             "Resetting device", vbasedev->name);

Here we set errp again when it's already set.

yes.

Maybe in this case just:

error_report_err(*errp);
*errp = NULL;
error_setg_errno(errp, errno,
                  "%s: Failed setting device in recover state. "
                  "Resetting device", vbasedev->name);
?

I see two alternatives for the recover state error :

1. append to the existing one, but we lack an error_append() helper
2. report as done today.

I tend to prefer 2. and we cab come back to 1. later on.

              goto reset_device;
          }
@@ -137,7 +139,7 @@ static int vfio_migration_set_state(VFIODevice *vbasedev,
               * This can happen if the device is asynchronously reset and
               * terminates a data transfer.
               */
-            error_report("%s: data_fd out of sync", vbasedev->name);
+            error_setg(errp, "%s: data_fd out of sync", vbasedev->name);
              close(mig_state->data_fd);

              return -EBADF;
@@ -168,10 +170,11 @@ reset_device:
   */
  static int
  vfio_migration_set_state_or_reset(VFIODevice *vbasedev,
-                                  enum vfio_device_mig_state new_state)
+                                  enum vfio_device_mig_state new_state,
+                                  Error **errp)
  {
      return vfio_migration_set_state(vbasedev, new_state,
-                                    VFIO_DEVICE_STATE_ERROR);
+                                    VFIO_DEVICE_STATE_ERROR, errp);
  }

  static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev,
@@ -399,10 +402,8 @@ static int vfio_save_setup(QEMUFile *f, void *opaque, 
Error **errp)
          switch (migration->device_state) {
          case VFIO_DEVICE_STATE_RUNNING:
              ret = vfio_migration_set_state(vbasedev, 
VFIO_DEVICE_STATE_PRE_COPY,
-                                           VFIO_DEVICE_STATE_RUNNING);
+                                           VFIO_DEVICE_STATE_RUNNING, errp);
              if (ret) {
-                error_setg(errp, "%s: Failed to set new PRE_COPY state",
-                           vbasedev->name);
                  return ret;
              }

@@ -435,13 +436,20 @@ static void vfio_save_cleanup(void *opaque)
  {
      VFIODevice *vbasedev = opaque;
      VFIOMigration *migration = vbasedev->migration;
+    Error *local_err = NULL;
+    int ret;

      /*
       * Changing device state from STOP_COPY to STOP can take time. Do it here,
       * after migration has completed, so it won't increase downtime.
       */
      if (migration->device_state == VFIO_DEVICE_STATE_STOP_COPY) {
-        vfio_migration_set_state_or_reset(vbasedev, VFIO_DEVICE_STATE_STOP);
+        ret = vfio_migration_set_state_or_reset(vbasedev,
+                                                VFIO_DEVICE_STATE_STOP,
+                                                &local_err);
+        if (ret) {
+            error_report_err(local_err);
+        }
      }

      g_free(migration->data_buffer);
@@ -549,11 +557,13 @@ static int vfio_save_complete_precopy(QEMUFile *f, void 
*opaque)
      VFIODevice *vbasedev = opaque;
      ssize_t data_size;
      int ret;
+    Error *local_err = NULL;

      /* We reach here with device state STOP or STOP_COPY only */
      ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP_COPY,
-                                   VFIO_DEVICE_STATE_STOP);
+                                   VFIO_DEVICE_STATE_STOP, &local_err);
      if (ret) {
+        error_report_err(local_err);
          return ret;
      }

@@ -591,14 +601,9 @@ static void vfio_save_state(QEMUFile *f, void *opaque)
  static int vfio_load_setup(QEMUFile *f, void *opaque, Error **errp)
  {
      VFIODevice *vbasedev = opaque;
-    int ret;

-    ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RESUMING,
-                                   vbasedev->migration->device_state);
-    if (ret) {
-        error_setg(errp, "%s: Failed to set RESUMING state", vbasedev->name);
-    }
-    return ret;
+    return vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RESUMING,
+                                    vbasedev->migration->device_state, errp);
  }

  static int vfio_load_cleanup(void *opaque)
@@ -714,19 +719,20 @@ static void vfio_vmstate_change_prepare(void *opaque, 
bool running,
      VFIODevice *vbasedev = opaque;
      VFIOMigration *migration = vbasedev->migration;
      enum vfio_device_mig_state new_state;
+    Error *local_err = NULL;
      int ret;

      new_state = migration->device_state == VFIO_DEVICE_STATE_PRE_COPY ?
                      VFIO_DEVICE_STATE_PRE_COPY_P2P :
                      VFIO_DEVICE_STATE_RUNNING_P2P;

-    ret = vfio_migration_set_state_or_reset(vbasedev, new_state);
+    ret = vfio_migration_set_state_or_reset(vbasedev, new_state, &local_err);
      if (ret) {
          /*
           * Migration should be aborted in this case, but vm_state_notify()
           * currently does not support reporting failures.
           */
-        migration_file_set_error(ret, NULL);
+        migration_file_set_error(ret, local_err);
      }

      trace_vfio_vmstate_change_prepare(vbasedev->name, running,
@@ -738,6 +744,7 @@ static void vfio_vmstate_change(void *opaque, bool running, 
RunState state)
  {
      VFIODevice *vbasedev = opaque;
      enum vfio_device_mig_state new_state;
+    Error *local_err = NULL;
      int ret;

      if (running) {
@@ -750,13 +757,13 @@ static void vfio_vmstate_change(void *opaque, bool 
running, RunState state)
                  VFIO_DEVICE_STATE_STOP;
      }

-    ret = vfio_migration_set_state_or_reset(vbasedev, new_state);
+    ret = vfio_migration_set_state_or_reset(vbasedev, new_state, &local_err);
      if (ret) {
          /*
           * Migration should be aborted in this case, but vm_state_notify()
           * currently does not support reporting failures.
           */
-        migration_file_set_error(ret, NULL);
+        migration_file_set_error(ret, local_err);
      }

      trace_vfio_vmstate_change(vbasedev->name, running, RunState_str(state),
@@ -769,13 +776,16 @@ static int 
vfio_migration_state_notifier(NotifierWithReturn *notifier,
      VFIOMigration *migration = container_of(notifier, VFIOMigration,
                                              migration_state);
      VFIODevice *vbasedev = migration->vbasedev;
+    int ret = 0;

      trace_vfio_migration_state_notifier(vbasedev->name, e->type);

      if (e->type == MIG_EVENT_PRECOPY_FAILED) {
-        vfio_migration_set_state_or_reset(vbasedev, VFIO_DEVICE_STATE_RUNNING);
+        ret = vfio_migration_set_state_or_reset(vbasedev,
+                                                VFIO_DEVICE_STATE_RUNNING,
+                                                errp);
      }
-    return 0;
+    return ret;

In MigrationNotifyFunc declaration it's stated that:

/*
  * A MigrationNotifyFunc may return an error code and an Error object,
  * but only when @e->type is MIG_EVENT_PRECOPY_SETUP.  The code is an int
  * to allow for different failure modes and recovery actions.
  */

And indeed migration_call_notifiers() will assert if this notifier fails on 
MIG_EVENT_PRECOPY_FAILED.

My series has been out of tree for too long :/

So I guess we should simply report the error locally and return 0.

yes. That said, I don't see why migrate_fd_cleanup() or postcopy_start()
could not use a local_err and report the error themselves. For later.
I will add a comment though.

Thanks,

C.

Thanks.

  }

  static void vfio_migration_free(VFIODevice *vbasedev)
--
2.45.0