[PATCH QEMU HCI-8.1 v5 36/36] VZ: migration: don't wait for stop-copy-only device state #VSTOR-150595

[Andrey Drobyshev <andrey.drobyshev@virtuozzo.com>]

A VFIO device reports its stop-copy state as pending data.  Once it
has nothing left to pre-copy, or doesn't pre-copy at all, nothing done
while the guest runs makes it smaller.  If it doesn't fit into
bandwidth x downtime-limit on its own, the migration iterates until
the limit is raised, which Nova does in steps of minutes.  An NVIDIA
vGPU reports ~2 GiB, so at the usual limits it never fits.

Have state_pending_exact handlers report such irreducible data and,
when it alone exceeds the threshold, switch over once the rest is
within the threshold plus as much again: waiting can't do better, and
squeezing the rest further only keeps the guest throttled.  Migrations
whose pending data fits the threshold are unaffected.

Signed-off-by: Andrey Drobyshev <andrey.drobyshev@virtuozzo.com>
---
 hw/vfio/migration.c   |  9 ++++++++-
 migration/migration.c | 17 +++++++++++++++--
 migration/migration.h |  2 ++
 migration/savevm.c    | 15 +++++++++++++--
 migration/savevm.h    |  5 +++--
 5 files changed, 41 insertions(+), 7 deletions(-)

diff --git a/hw/vfio/migration.c b/hw/vfio/migration.c
index 8f2722dc671..c7312d9cb58 100644
--- a/hw/vfio/migration.c
+++ b/hw/vfio/migration.c
@@ -569,18 +569,25 @@ static void vfio_state_pending_exact(void *opaque, uint64_t *must_precopy,
     VFIODevice *vbasedev = opaque;
     VFIOMigration *migration = vbasedev->migration;
     uint64_t stop_copy_size = VFIO_MIG_STOP_COPY_SIZE;
+    int ret;
 
     /*
      * If getting pending migration size fails, VFIO_MIG_STOP_COPY_SIZE is
      * reported so downtime limit won't be violated.
      */
-    vfio_query_stop_copy_size(vbasedev, &stop_copy_size);
+    ret = vfio_query_stop_copy_size(vbasedev, &stop_copy_size);
     *must_precopy += stop_copy_size;
 
     if (vfio_device_state_is_precopy(vbasedev)) {
         vfio_query_precopy_size(migration);
     }
 
+    /* Once there's nothing left to pre-copy, iterating can't shrink it */
+    if (!ret && !migration->precopy_init_size &&
+        !migration->precopy_dirty_size) {
+        qemu_savevm_state_pending_add_irreducible(stop_copy_size);
+    }
+
     trace_vfio_state_pending_exact(vbasedev->name, *must_precopy, *can_postcopy,
                                    stop_copy_size, migration->precopy_init_size,
                                    migration->precopy_dirty_size);
diff --git a/migration/migration.c b/migration/migration.c
index 5f488836ab1..4a7da07fa05 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -1840,6 +1840,7 @@ int migrate_init(MigrationState *s, Error **errp)
     s->rp_state.from_dst_file = NULL;
     s->mbps = 0.0;
     s->switchover_bw_per_ms = 0.0;
+    s->irreducible_pending = 0;
     s->pages_per_second = 0.0;
     s->downtime = 0;
     s->expected_downtime = 0;
@@ -3576,8 +3577,10 @@ static MigIterateState migration_iteration_run(MigrationState *s)
          * postcopy started, so ESTIMATE should always match with EXACT
          * during postcopy phase.
          */
-        if (pending_size < s->threshold_size) {
-            qemu_savevm_state_pending_exact(&must_precopy, &can_postcopy);
+        /* Allow for what the estimate lacks, see the irreducible rule below */
+        if (pending_size < s->threshold_size + 2 * s->irreducible_pending) {
+            s->irreducible_pending =
+                qemu_savevm_state_pending_exact(&must_precopy, &can_postcopy);
             pending_size = must_precopy + can_postcopy;
             trace_migrate_pending_exact(pending_size, must_precopy,
                                         can_postcopy);
@@ -3601,6 +3604,16 @@ static MigIterateState migration_iteration_run(MigrationState *s)
          *     (which was calculated from expected downtime)
          */
         complete_ready = can_switchover && (pending_size <= s->threshold_size);
+
+        /*
+         * Data which only moves once the guest is stopped can't shrink by
+         * iterating: if it alone exceeds the threshold, switch over once
+         * the rest is within the threshold plus as much again.
+         */
+        if (s->irreducible_pending > s->threshold_size) {
+            complete_ready = can_switchover &&
+                pending_size <= s->threshold_size + 2 * s->irreducible_pending;
+        }
     }
 
     if (complete_ready) {
diff --git a/migration/migration.h b/migration/migration.h
index e2cdb087321..d5df6ce495f 100644
--- a/migration/migration.h
+++ b/migration/migration.h
@@ -316,6 +316,8 @@ struct MigrationState {
      * measured bandwidth, or avail-switchover-bandwidth if specified.
      */
     uint64_t threshold_size;
+    /* Pending data which only moves once stopped, from the last exact query */
+    uint64_t irreducible_pending;
 
     /* params from 'migrate-set-parameters' */
     MigrationParameters parameters;
diff --git a/migration/savevm.c b/migration/savevm.c
index 3b768f4f4e0..f4df8308c2d 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -1752,13 +1752,23 @@ void qemu_savevm_state_pending_estimate(uint64_t *must_precopy,
     }
 }
 
-void qemu_savevm_state_pending_exact(uint64_t *must_precopy,
-                                     uint64_t *can_postcopy)
+/* Exact pending data which only moves once the guest is stopped */
+static uint64_t savevm_pending_irreducible;
+
+void qemu_savevm_state_pending_add_irreducible(uint64_t size)
+{
+    savevm_pending_irreducible += size;
+}
+
+/* Returns the part of the pending data which only moves once stopped */
+uint64_t qemu_savevm_state_pending_exact(uint64_t *must_precopy,
+                                         uint64_t *can_postcopy)
 {
     SaveStateEntry *se;
 
     *must_precopy = 0;
     *can_postcopy = 0;
+    savevm_pending_irreducible = 0;
 
     QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
         if (!se->ops || !se->ops->state_pending_exact) {
@@ -1771,6 +1781,7 @@ void qemu_savevm_state_pending_exact(uint64_t *must_precopy,
         }
         se->ops->state_pending_exact(se->opaque, must_precopy, can_postcopy);
     }
+    return savevm_pending_irreducible;
 }
 
 void qemu_savevm_state_cleanup(void)
diff --git a/migration/savevm.h b/migration/savevm.h
index 2d5e9c71668..dc37a4ba194 100644
--- a/migration/savevm.h
+++ b/migration/savevm.h
@@ -40,10 +40,11 @@ int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy);
 void qemu_savevm_state_cleanup(void);
 void qemu_savevm_state_complete_postcopy(QEMUFile *f);
 int qemu_savevm_state_complete_precopy(QEMUFile *f, bool iterable_only);
-void qemu_savevm_state_pending_exact(uint64_t *must_precopy,
-                                     uint64_t *can_postcopy);
+uint64_t qemu_savevm_state_pending_exact(uint64_t *must_precopy,
+                                         uint64_t *can_postcopy);
 void qemu_savevm_state_pending_estimate(uint64_t *must_precopy,
                                         uint64_t *can_postcopy);
+void qemu_savevm_state_pending_add_irreducible(uint64_t size);
 int qemu_savevm_state_complete_precopy_iterable(QEMUFile *f, bool in_postcopy);
 bool qemu_savevm_state_postcopy_prepare(QEMUFile *f, Error **errp);
 void qemu_savevm_send_ping(QEMUFile *f, uint32_t value);

-- 
2.47.1