Skip to contentSkip to conversation

migration/ram.c: Refactor compress code

PATCH Superseded Lukas Straub 4 participants 23 messages Apr 2, 2023 – Apr 5, 2023 Arm/Amlogic Meson SoC support

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover migration/ram.c: Refactor compress code

This series refactors the ram compress code.

It first removes ram.c dependencies from the core compress code, then moves it out to its own file. Finally, on the migration destination side the initialisation and cleanup of compress threads is moved out of ram.c to migration.c. This allows using COLO with compress enabled.

This series is based on the following series:
https://lore.kernel.org/qemu-devel/af76761aa6978071c5b8e9b872b697db465a5520.1680457631.git.lukasstraub2@web.de/T/#t

Lukas Straub (14):
ram.c: Let the compress threads return a CompressResult enum ram.c: Dont change param->block in the compress thread ram.c: Reset result after sending queued data
ram.c: Do not call save_page_header() from compress threads ram.c: Call update_compress_thread_counts from
compress_send_queued_data
ram.c: Remove last ram.c dependency from the core compress code ram.c: Introduce whitespace (squash with next patch) ram.c: Move core compression code into its own file ram.c: Remove whitespace (squash with previous patch) ram.c: Move core decompression code into its own file ram compress: Assert that the file buffer matches the result ram.c: Remove unused include after moving out code ram-compress.c: Make target independent
migration: Initialize and cleanup decompression in migration.c

 migration/meson.build    |   5 +-
 migration/migration.c    |   9 +
 migration/qemu-file.c    |  11 +
 migration/qemu-file.h    |   1 +
 migration/ram-compress.c | 483 ++++++++++++++++++++++++++++++++++++++
 migration/ram-compress.h |  70 ++++++
 migration/ram.c          | 490 +++------------------------------------
 7 files changed, 615 insertions(+), 454 deletions(-)
 create mode 100644 migration/ram-compress.c
 create mode 100644 migration/ram-compress.h

--
2.30.2

#4 lore raw

PATCH 2/14 ram.c: Dont change param->block in the compress thread

Instead introduce a extra parameter to trigger the compress thread. Now, when the compress thread is done, we know what RAMBlock and offset it did compress.

This will be used in the next commits to move save_page_header() out of compress code.

---
 migration/ram.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
migration/ram.c +4 -2
index ca561e62bd..3c9fac086d 100644
@@ -503,6 +503,7 @@ typedef enum CompressResult CompressResult;
 struct CompressParam {
     bool done;
     bool quit;
+    bool trigger;
     CompressResult result;
     QEMUFile *file;
     QemuMutex mutex;
@@ -576,10 +577,10 @@ static void *do_data_compress(void *opaque)
 
     qemu_mutex_lock(&param->mutex);
     while (!param->quit) {
-        if (param->block) {
+        if (param->trigger) {
             block = param->block;
             offset = param->offset;
-            param->block = NULL;
+            param->trigger = false;
             qemu_mutex_unlock(&param->mutex);
 
             result = do_compress_ram_page(param->file, &param->stream,
@@ -1556,6 +1557,7 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block,
 {
     param->block = block;
     param->offset = offset;
+    param->trigger = true;
 }
 
 static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset)

--
2.30.2

#1 lore raw

PATCH 1/14 ram.c: Let the compress threads return a CompressResult enum

In reply to Lukas Straub

This will be used in the next commits to move save_page_header() out of compress code.

---
 migration/ram.c | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)
migration/ram.c +22 -12
index 9d1817ab7b..ca561e62bd 100644
@@ -493,10 +493,17 @@ MigrationOps *migration_ops;
 
 CompressionStats compression_counters;
 
+enum CompressResult {
+    RES_NONE = 0,
+    RES_ZEROPAGE = 1,
+    RES_COMPRESS = 2
+};
+typedef enum CompressResult CompressResult;
+
 struct CompressParam {
     bool done;
     bool quit;
-    bool zero_page;
+    CompressResult result;
     QEMUFile *file;
     QemuMutex mutex;
     QemuCond cond;
@@ -538,8 +545,9 @@ static QemuCond decomp_done_cond;
 
 static int ram_save_host_page_urgent(PageSearchStatus *pss);
 
-static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
-                                 ram_addr_t offset, uint8_t *source_buf);
+static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
+                                           RAMBlock *block, ram_addr_t offset,
+                                           uint8_t *source_buf);
 
 /* NOTE: page is the PFN not real ram_addr_t. */
 static void pss_init(PageSearchStatus *pss, RAMBlock *rb, ram_addr_t page)
@@ -564,7 +572,7 @@ static void *do_data_compress(void *opaque)
     CompressParam *param = opaque;
     RAMBlock *block;
     ram_addr_t offset;
-    bool zero_page;
+    CompressResult result;
 
     qemu_mutex_lock(&param->mutex);
     while (!param->quit) {
@@ -574,12 +582,12 @@ static void *do_data_compress(void *opaque)
             param->block = NULL;
             qemu_mutex_unlock(&param->mutex);
 
-            zero_page = do_compress_ram_page(param->file, &param->stream,
-                                             block, offset, param->originbuf);
+            result = do_compress_ram_page(param->file, &param->stream,
+                                          block, offset, param->originbuf);
 
             qemu_mutex_lock(&comp_done_lock);
             param->done = true;
-            param->zero_page = zero_page;
+            param->result = result;
             qemu_cond_signal(&comp_done_cond);
             qemu_mutex_unlock(&comp_done_lock);
 
@@ -1463,8 +1471,9 @@ static int ram_save_multifd_page(QEMUFile *file, RAMBlock *block,
     return 1;
 }
 
-static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
-                                 ram_addr_t offset, uint8_t *source_buf)
+static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
+                                           RAMBlock *block, ram_addr_t offset,
+                                           uint8_t *source_buf)
 {
     RAMState *rs = ram_state;
     PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY];
@@ -1472,7 +1481,7 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
     int ret;
 
     if (save_zero_page_to_file(pss, f, block, offset)) {
-        return true;
+        return RES_ZEROPAGE;
     }
 
     save_page_header(pss, f, block, offset | RAM_SAVE_FLAG_COMPRESS_PAGE);
@@ -1487,8 +1496,9 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
     if (ret < 0) {
         qemu_file_set_error(migrate_get_current()->to_dst_file, ret);
         error_report("compressed data failed!");
+        return RES_NONE;
     }
-    return false;
+    return RES_COMPRESS;
 }
 
 static void
@@ -1496,7 +1506,7 @@ update_compress_thread_counts(const CompressParam *param, int bytes_xmit)
 {
     ram_transferred_add(bytes_xmit);
 
-    if (param->zero_page) {
+    if (param->result == RES_ZEROPAGE) {
         stat64_add(&ram_atomic_counters.duplicate, 1);
         return;
     }

--
2.30.2

#5 lore raw

PATCH 3/14 ram.c: Reset result after sending queued data

In reply to Lukas Straub

And take the param->mutex lock for the whole section to ensure thread-safety.
Now, it is explicitly clear if there is no queued data to send. Before, this was handled by param->file stream being empty and thus qemu_put_qemu_file() not sending anything.

This will be used in the next commits to move save_page_header() out of compress code.

---
 migration/ram.c | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)
migration/ram.c +22 -10
index 3c9fac086d..bef6292ef7 100644
@@ -1519,6 +1519,13 @@ update_compress_thread_counts(const CompressParam *param, int bytes_xmit)
 
 static bool save_page_use_compression(RAMState *rs);
 
+static inline void compress_reset_result(CompressParam *param)
+{
+    param->result = RES_NONE;
+    param->block = NULL;
+    param->offset = 0;
+}
+
 static void flush_compressed_data(RAMState *rs)
 {
     MigrationState *ms = migrate_get_current();
@@ -1540,13 +1547,16 @@ static void flush_compressed_data(RAMState *rs)
     for (idx = 0; idx < thread_count; idx++) {
         qemu_mutex_lock(&comp_param[idx].mutex);
         if (!comp_param[idx].quit) {
-            len = qemu_put_qemu_file(ms->to_dst_file, comp_param[idx].file);
+            CompressParam *param = &comp_param[idx];
+            len = qemu_put_qemu_file(ms->to_dst_file, param->file);
+            compress_reset_result(param);
+
             /*
              * it's safe to fetch zero_page without holding comp_done_lock
              * as there is no further request submitted to the thread,
              * i.e, the thread should be waiting for a request at this point.
              */
-            update_compress_thread_counts(&comp_param[idx], len);
+            update_compress_thread_counts(param, len);
         }
         qemu_mutex_unlock(&comp_param[idx].mutex);
     }
@@ -1571,15 +1581,17 @@ static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset)
 retry:
     for (idx = 0; idx < thread_count; idx++) {
         if (comp_param[idx].done) {
-            comp_param[idx].done = false;
-            bytes_xmit = qemu_put_qemu_file(ms->to_dst_file,
-                                            comp_param[idx].file);
-            qemu_mutex_lock(&comp_param[idx].mutex);
-            set_compress_params(&comp_param[idx], block, offset);
-            qemu_cond_signal(&comp_param[idx].cond);
-            qemu_mutex_unlock(&comp_param[idx].mutex);
+            CompressParam *param = &comp_param[idx];
+            qemu_mutex_lock(&param->mutex);
+            param->done = false;
+            bytes_xmit = qemu_put_qemu_file(ms->to_dst_file, param->file);
+            compress_reset_result(param);
+            set_compress_params(param, block, offset);
+
+            update_compress_thread_counts(param, bytes_xmit);
+            qemu_cond_signal(&param->cond);
+            qemu_mutex_unlock(&param->mutex);
             pages = 1;
-            update_compress_thread_counts(&comp_param[idx], bytes_xmit);
             break;
         }
     }

--
2.30.2

#6 lore raw

PATCH 4/14 ram.c: Do not call save_page_header() from compress threads

In reply to Lukas Straub

save_page_header() accesses several global variables, so calling it from multiple threads is pretty ugly.

Instead, call save_page_header() before writing out the compressed data from the compress buffer to the migration stream.

This also makes the core compress code more independend from ram.c.

---
 migration/ram.c | 44 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 35 insertions(+), 9 deletions(-)
migration/ram.c +35 -9
index bef6292ef7..7ab008145b 100644
@@ -1476,17 +1476,13 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
                                            RAMBlock *block, ram_addr_t offset,
                                            uint8_t *source_buf)
 {
-    RAMState *rs = ram_state;
-    PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY];
     uint8_t *p = block->host + offset;
     int ret;
 
-    if (save_zero_page_to_file(pss, f, block, offset)) {
+    if (buffer_is_zero(p, TARGET_PAGE_SIZE)) {
         return RES_ZEROPAGE;
     }
 
-    save_page_header(pss, f, block, offset | RAM_SAVE_FLAG_COMPRESS_PAGE);
-
     /*
      * copy it to a internal buffer to avoid it being modified by VM
      * so that we can catch up the error during compression and
@@ -1526,9 +1522,40 @@ static inline void compress_reset_result(CompressParam *param)
     param->offset = 0;
 }
 
-static void flush_compressed_data(RAMState *rs)
+static int send_queued_data(CompressParam *param)
 {
+    PageSearchStatus *pss = &ram_state->pss[RAM_CHANNEL_PRECOPY];
     MigrationState *ms = migrate_get_current();
+    QEMUFile *file = ms->to_dst_file;
+    int len = 0;
+
+    RAMBlock *block = param->block;
+    ram_addr_t offset = param->offset;
+
+    if (param->result == RES_NONE) {
+        return 0;
+    }
+
+    assert(block == pss->last_sent_block);
+
+    if (param->result == RES_ZEROPAGE) {
+        len += save_page_header(pss, file, block, offset | RAM_SAVE_FLAG_ZERO);
+        qemu_put_byte(file, 0);
+        len += 1;
+        ram_release_page(block->idstr, offset);
+    } else if (param->result == RES_COMPRESS) {
+        len += save_page_header(pss, file, block,
+                                offset | RAM_SAVE_FLAG_COMPRESS_PAGE);
+        len += qemu_put_qemu_file(file, param->file);
+    } else {
+        abort();
+    }
+
+    return len;
+}
+
+static void flush_compressed_data(RAMState *rs)
+{
     int idx, len, thread_count;
 
     if (!save_page_use_compression(rs)) {
@@ -1548,7 +1575,7 @@ static void flush_compressed_data(RAMState *rs)
         qemu_mutex_lock(&comp_param[idx].mutex);
         if (!comp_param[idx].quit) {
             CompressParam *param = &comp_param[idx];
-            len = qemu_put_qemu_file(ms->to_dst_file, param->file);
+            len = send_queued_data(param);
             compress_reset_result(param);
 
             /*
@@ -1574,7 +1601,6 @@ static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset)
 {
     int idx, thread_count, bytes_xmit = -1, pages = -1;
     bool wait = migrate_compress_wait_thread();
-    MigrationState *ms = migrate_get_current();
 
     thread_count = migrate_compress_threads();
     qemu_mutex_lock(&comp_done_lock);
@@ -1584,7 +1610,7 @@ retry:
             CompressParam *param = &comp_param[idx];
             qemu_mutex_lock(&param->mutex);
             param->done = false;
-            bytes_xmit = qemu_put_qemu_file(ms->to_dst_file, param->file);
+            bytes_xmit = send_queued_data(param);
             compress_reset_result(param);
             set_compress_params(param, block, offset);
 

--
2.30.2

#10 lore raw

PATCH 8/14 ram.c: Move core compression code into its own file

In reply to Lukas Straub

No functional changes intended.

---
 migration/meson.build    |   5 +-
 migration/ram-compress.c | 273 +++++++++++++++++++++++++++++++++++++++
 migration/ram-compress.h |  65 ++++++++++
 migration/ram.c          | 255 +-----------------------------------
 4 files changed, 343 insertions(+), 255 deletions(-)
 create mode 100644 migration/ram-compress.c
 create mode 100644 migration/ram-compress.h
migration/meson.build +4 -1
index 0d1bb9f96e..262e3c9754 100644
@@ -36,4 +36,7 @@ endif
 softmmu_ss.add(when: zstd, if_true: files('multifd-zstd.c'))
 
 specific_ss.add(when: 'CONFIG_SOFTMMU',
-                if_true: files('dirtyrate.c', 'ram.c', 'target.c'))
+                if_true: files('dirtyrate.c',
+                               'ram.c',
+                               'ram-compress.c',
+                               'target.c'))
migration/ram-compress.c new file +273 -0

273 lines not on this page · raw message

migration/ram-compress.h new file +65 -0

65 lines not on this page · raw message

migration/ram.c +1 -254

324 lines not on this page · raw message

--
2.30.2

#9 lore raw

PATCH 7/14 ram.c: Introduce whitespace (squash with next patch)

In reply to Lukas Straub

Introduce whitespace to make it easier to reroll the series.

---
 migration/ram.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)
migration/ram.c +12 -0
index 20428ccf42..475c04a18b 100644
@@ -602,6 +602,12 @@ static void *do_data_compress(void *opaque)
     return NULL;
 }
 
+
+
+/* split */
+
+
+
 static void compress_threads_save_cleanup(void)
 {
     int i, thread_count;
@@ -641,6 +647,12 @@ static void compress_threads_save_cleanup(void)
     comp_param = NULL;
 }
 
+
+
+/* split */
+
+
+
 static int compress_threads_save_setup(void)
 {
     int i, thread_count;

--
2.30.2

#14 lore raw

PATCH 11/14 ram compress: Assert that the file buffer matches the result

In reply to Lukas Straub

Before this series, "nothing to send" was handled by the file buffer being empty. Now it is tracked via param->result.

Assert that the file buffer state matches the result.

---
 migration/qemu-file.c    | 11 +++++++++++
 migration/qemu-file.h    |  1 +
 migration/ram-compress.c |  5 +++++
 migration/ram.c          |  2 ++
 4 files changed, 19 insertions(+)
migration/qemu-file.c +11 -0
index 102ab3b439..2b3f3f8549 100644
@@ -887,6 +887,17 @@ int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src)
     return len;
 }
 
+/*
+ * Check if the writable buffer is empty
+ */
+
+bool qemu_file_buffer_empty(QEMUFile *file)
+{
+    assert(qemu_file_is_writable(file));
+
+    return !file->iovcnt;
+}
+
 /*
  * Get a string whose length is determined by a single preceding byte
  * A preallocated 256 byte buffer must be passed in.
migration/qemu-file.h +1 -0
index 9d0155a2a1..15e5f189f0 100644
@@ -113,6 +113,7 @@ size_t qemu_get_buffer_in_place(QEMUFile *f, uint8_t **buf, size_t size);
 ssize_t qemu_put_compression_data(QEMUFile *f, z_stream *stream,
                                   const uint8_t *p, size_t size);
 int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src);
+bool qemu_file_buffer_empty(QEMUFile *file);
 
 /*
  * Note that you can only peek continuous bytes from where the current pointer
migration/ram-compress.c +5 -0
index f75b8c3079..b75a9d2b9a 100644
@@ -193,6 +193,8 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
     uint8_t *p = block->host + offset;
     int ret;
 
+    assert(qemu_file_buffer_empty(f));
+
     if (buffer_is_zero(p, TARGET_PAGE_SIZE)) {
         return RES_ZEROPAGE;
     }
@@ -207,6 +209,7 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
     if (ret < 0) {
         qemu_file_set_error(migrate_get_current()->to_dst_file, ret);
         error_report("compressed data failed!");
+        qemu_fflush(f);
         return RES_NONE;
     }
     return RES_COMPRESS;
@@ -238,6 +241,7 @@ void flush_compressed_data(int (send_queued_data(CompressParam *)))
         if (!comp_param[idx].quit) {
             CompressParam *param = &comp_param[idx];
             send_queued_data(param);
+            assert(qemu_file_buffer_empty(param->file));
             compress_reset_result(param);
         }
         qemu_mutex_unlock(&comp_param[idx].mutex);
@@ -267,6 +271,7 @@ retry:
             qemu_mutex_lock(&param->mutex);
             param->done = false;
             send_queued_data(param);
+            assert(qemu_file_buffer_empty(param->file));
             compress_reset_result(param);
             set_compress_params(param, block, offset);
 
migration/ram.c +2 -0
index 5a2486bf89..7a8f540737 100644
@@ -1333,11 +1333,13 @@ static int send_queued_data(CompressParam *param)
     assert(block == pss->last_sent_block);
 
     if (param->result == RES_ZEROPAGE) {
+        assert(qemu_file_buffer_empty(param->file));
         len += save_page_header(pss, file, block, offset | RAM_SAVE_FLAG_ZERO);
         qemu_put_byte(file, 0);
         len += 1;
         ram_release_page(block->idstr, offset);
     } else if (param->result == RES_COMPRESS) {
+        assert(!qemu_file_buffer_empty(param->file));
         len += save_page_header(pss, file, block,
                                 offset | RAM_SAVE_FLAG_COMPRESS_PAGE);
         len += qemu_put_qemu_file(file, param->file);

--
2.30.2

#15 lore raw

PATCH 12/14 ram.c: Remove unused include after moving out code

In reply to Lukas Straub
---
 migration/ram.c | 1 -
 1 file changed, 1 deletion(-)
migration/ram.c +0 -1
index 7a8f540737..9072d70f7c 100644
@@ -32,7 +32,6 @@
 #include "qemu/bitmap.h"
 #include "qemu/madvise.h"
 #include "qemu/main-loop.h"
-#include "io/channel-null.h"
 #include "xbzrle.h"
 #include "ram-compress.h"
 #include "ram.h"

--
2.30.2

#17 lore raw

PATCH 13/14 ram-compress.c: Make target independent

In reply to Lukas Straub

Make ram-compress.c target independent.

---
 migration/meson.build    |  2 +-
 migration/ram-compress.c | 16 +++++++++-------
 2 files changed, 10 insertions(+), 8 deletions(-)
migration/meson.build +1 -1
index 262e3c9754..16f642031c 100644
@@ -22,6 +22,7 @@ softmmu_ss.add(files(
   'migration.c',
   'multifd.c',
   'multifd-zlib.c',
+  'ram-compress.c',
   'postcopy-ram.c',
   'savevm.c',
   'socket.c',
@@ -38,5 +39,4 @@ softmmu_ss.add(when: zstd, if_true: files('multifd-zstd.c'))
 specific_ss.add(when: 'CONFIG_SOFTMMU',
                 if_true: files('dirtyrate.c',
                                'ram.c',
-                               'ram-compress.c',
                                'target.c'))
migration/ram-compress.c +9 -7
index b75a9d2b9a..a75c6e0573 100644
@@ -34,7 +34,8 @@
 #include "qemu/error-report.h"
 #include "migration.h"
 #include "io/channel-null.h"
-#include "exec/ram_addr.h"
+#include "exec/target_page.h"
+#include "exec/ramblock.h"
 
 CompressionStats compression_counters;
 
@@ -155,7 +156,7 @@ int compress_threads_save_setup(void)
     qemu_cond_init(&comp_done_cond);
     qemu_mutex_init(&comp_done_lock);
     for (i = 0; i < thread_count; i++) {
-        comp_param[i].originbuf = g_try_malloc(TARGET_PAGE_SIZE);
+        comp_param[i].originbuf = g_try_malloc(qemu_target_page_size());
         if (!comp_param[i].originbuf) {
             goto exit;
         }
@@ -195,7 +196,7 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
 
     assert(qemu_file_buffer_empty(f));
 
-    if (buffer_is_zero(p, TARGET_PAGE_SIZE)) {
+    if (buffer_is_zero(p, qemu_target_page_size())) {
         return RES_ZEROPAGE;
     }
 
@@ -204,8 +205,8 @@ static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
      * so that we can catch up the error during compression and
      * decompression
      */
-    memcpy(source_buf, p, TARGET_PAGE_SIZE);
-    ret = qemu_put_compression_data(f, stream, source_buf, TARGET_PAGE_SIZE);
+    memcpy(source_buf, p, qemu_target_page_size());
+    ret = qemu_put_compression_data(f, stream, source_buf, qemu_target_page_size());
     if (ret < 0) {
         qemu_file_set_error(migrate_get_current()->to_dst_file, ret);
         error_report("compressed data failed!");
@@ -335,7 +336,7 @@ static void *do_data_decompress(void *opaque)
             param->des = 0;
             qemu_mutex_unlock(&param->mutex);
 
-            pagesize = TARGET_PAGE_SIZE;
+            pagesize = qemu_target_page_size();
 
             ret = qemu_uncompress_data(&param->stream, des, pagesize,
                                        param->compbuf, len);
@@ -438,7 +439,8 @@ int compress_threads_load_setup(QEMUFile *f)
             goto exit;
         }
 
-        decomp_param[i].compbuf = g_malloc0(compressBound(TARGET_PAGE_SIZE));
+        size_t compbuf_size = compressBound(qemu_target_page_size());
+        decomp_param[i].compbuf = g_malloc0(compbuf_size);
         qemu_mutex_init(&decomp_param[i].mutex);
         qemu_cond_init(&decomp_param[i].cond);
         decomp_param[i].done = true;

--
2.30.2

#7 lore raw

PATCH 5/14 ram.c: Call update_compress_thread_counts from compress_send_queued_data

In reply to Lukas Straub

This makes the core compress code more independend from ram.c.

---
 migration/ram.c | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)
migration/ram.c +6 -12
index 7ab008145b..f55eb0e587 100644
@@ -1551,12 +1551,14 @@ static int send_queued_data(CompressParam *param)
         abort();
     }
 
+    update_compress_thread_counts(param, len);
+
     return len;
 }
 
 static void flush_compressed_data(RAMState *rs)
 {
-    int idx, len, thread_count;
+    int idx, thread_count;
 
     if (!save_page_use_compression(rs)) {
         return;
@@ -1575,15 +1577,8 @@ static void flush_compressed_data(RAMState *rs)
         qemu_mutex_lock(&comp_param[idx].mutex);
         if (!comp_param[idx].quit) {
             CompressParam *param = &comp_param[idx];
-            len = send_queued_data(param);
+            send_queued_data(param);
             compress_reset_result(param);
-
-            /*
-             * it's safe to fetch zero_page without holding comp_done_lock
-             * as there is no further request submitted to the thread,
-             * i.e, the thread should be waiting for a request at this point.
-             */
-            update_compress_thread_counts(param, len);
         }
         qemu_mutex_unlock(&comp_param[idx].mutex);
     }
@@ -1599,7 +1594,7 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block,
 
 static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset)
 {
-    int idx, thread_count, bytes_xmit = -1, pages = -1;
+    int idx, thread_count, pages = -1;
     bool wait = migrate_compress_wait_thread();
 
     thread_count = migrate_compress_threads();
@@ -1610,11 +1605,10 @@ retry:
             CompressParam *param = &comp_param[idx];
             qemu_mutex_lock(&param->mutex);
             param->done = false;
-            bytes_xmit = send_queued_data(param);
+            send_queued_data(param);
             compress_reset_result(param);
             set_compress_params(param, block, offset);
 
-            update_compress_thread_counts(param, bytes_xmit);
             qemu_cond_signal(&param->cond);
             qemu_mutex_unlock(&param->mutex);
             pages = 1;

--
2.30.2

#11 lore raw

PATCH 9/14 ram.c: Remove whitespace (squash with previous patch)

In reply to Lukas Straub
---
 migration/ram.c | 18 ------------------
 1 file changed, 18 deletions(-)
migration/ram.c +0 -18
index 114901241e..31b9b0b9ec 100644
@@ -530,24 +530,6 @@ static bool pss_overlap(PageSearchStatus *pss1, PageSearchStatus *pss2)
         (pss1->host_page_start == pss2->host_page_start);
 }
 
-
-
-
-
-/* split */
-
-
-
-
-
-
-
-/* split */
-
-
-
-
-
 /**
  * save_page_header: write page header to wire
  *

--
2.30.2

#8 lore raw

PATCH 6/14 ram.c: Remove last ram.c dependency from the core compress code

In reply to Lukas Straub

Make compression interfaces take send_queued_data() as an argument. Remove save_page_use_compression() from flush_compressed_data().

This removes the last ram.c dependency from the core compress code.

---
 migration/ram.c | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)
migration/ram.c +17 -10
index f55eb0e587..20428ccf42 100644
@@ -1556,13 +1556,10 @@ static int send_queued_data(CompressParam *param)
     return len;
 }
 
-static void flush_compressed_data(RAMState *rs)
+static void flush_compressed_data(int (send_queued_data(CompressParam *)))
 {
     int idx, thread_count;
 
-    if (!save_page_use_compression(rs)) {
-        return;
-    }
     thread_count = migrate_compress_threads();
 
     qemu_mutex_lock(&comp_done_lock);
@@ -1584,6 +1581,15 @@ static void flush_compressed_data(RAMState *rs)
     }
 }
 
+static void ram_flush_compressed_data(RAMState *rs)
+{
+    if (!save_page_use_compression(rs)) {
+        return;
+    }
+
+    flush_compressed_data(send_queued_data);
+}
+
 static inline void set_compress_params(CompressParam *param, RAMBlock *block,
                                        ram_addr_t offset)
 {
@@ -1592,7 +1598,8 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block,
     param->trigger = true;
 }
 
-static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset)
+static int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset,
+                                int (send_queued_data(CompressParam *)))
 {
     int idx, thread_count, pages = -1;
     bool wait = migrate_compress_wait_thread();
@@ -1673,7 +1680,7 @@ static int find_dirty_block(RAMState *rs, PageSearchStatus *pss)
              * Also If xbzrle is on, stop using the data compression at this
              * point. In theory, xbzrle can do better than compression.
              */
-            flush_compressed_data(rs);
+            ram_flush_compressed_data(rs);
 
             /* Hit the end of the list */
             pss->block = QLIST_FIRST_RCU(&ram_list.blocks);
@@ -2363,11 +2370,11 @@ static bool save_compress_page(RAMState *rs, PageSearchStatus *pss,
      * much CPU resource.
      */
     if (block != pss->last_sent_block) {
-        flush_compressed_data(rs);
+        ram_flush_compressed_data(rs);
         return false;
     }
 
-    if (compress_page_with_multi_thread(block, offset) > 0) {
+    if (compress_page_with_multi_thread(block, offset, send_queued_data) > 0) {
         return true;
     }
 
@@ -3419,7 +3426,7 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
              * page is sent in one chunk.
              */
             if (migrate_postcopy_ram()) {
-                flush_compressed_data(rs);
+                ram_flush_compressed_data(rs);
             }
 
             /*
@@ -3512,7 +3519,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque)
         }
         qemu_mutex_unlock(&rs->bitmap_mutex);
 
-        flush_compressed_data(rs);
+        ram_flush_compressed_data(rs);
         ram_control_after_iterate(f, RAM_CONTROL_FINISH);
     }
 

--
2.30.2

#19 lore raw

PATCH 14/14 migration: Initialize and cleanup decompression in migration.c

In reply to Lukas Straub

This fixes compress with colo.

---
 migration/migration.c | 9 +++++++++
 migration/ram.c       | 5 -----
 2 files changed, 9 insertions(+), 5 deletions(-)
migration/migration.c +9 -0
index ae2025d9d8..cbdc10b840 100644
@@ -26,6 +26,7 @@
 #include "sysemu/cpu-throttle.h"
 #include "rdma.h"
 #include "ram.h"
+#include "ram-compress.h"
 #include "migration/global_state.h"
 #include "migration/misc.h"
 #include "migration.h"
@@ -316,6 +317,7 @@ void migration_incoming_state_destroy(void)
     struct MigrationIncomingState *mis = migration_incoming_get_current();
 
     multifd_load_cleanup();
+    compress_threads_load_cleanup();
 
     if (mis->to_src_file) {
         /* Tell source that we are done */
@@ -598,6 +600,12 @@ process_incoming_migration_co(void *opaque)
     Error *local_err = NULL;
 
     assert(mis->from_src_file);
+
+    if (compress_threads_load_setup(mis->from_src_file)) {
+        error_report("Failed to setup decompress threads");
+        goto fail;
+    }
+
     mis->migration_incoming_co = qemu_coroutine_self();
     mis->largest_page_size = qemu_ram_pagesize_largest();
     postcopy_state_set(POSTCOPY_INCOMING_NONE);
@@ -663,6 +671,7 @@ fail:
     qemu_fclose(mis->from_src_file);
 
     multifd_load_cleanup();
+    compress_threads_load_cleanup();
 
     exit(EXIT_FAILURE);
 }
migration/ram.c +0 -5
index 9072d70f7c..e9a295fab9 100644
@@ -3559,10 +3559,6 @@ void colo_release_ram_cache(void)
  */
 static int ram_load_setup(QEMUFile *f, void *opaque)
 {
-    if (compress_threads_load_setup(f)) {
-        return -1;
-    }
-
     xbzrle_load_setup();
     ramblock_recv_map_init();
 
@@ -3578,7 +3574,6 @@ static int ram_load_cleanup(void *opaque)
     }
 
     xbzrle_load_cleanup();
-    compress_threads_load_cleanup();
 
     RAMBLOCK_FOREACH_NOT_IGNORED(rb) {
         g_free(rb->receivedmap);

--
2.30.2

#12 lore raw

PATCH 10/14 ram.c: Move core decompression code into its own file

In reply to Lukas Straub

No functional changes intended.

---
 migration/ram-compress.c | 203 ++++++++++++++++++++++++++++++++++++++
 migration/ram-compress.h |   5 +
 migration/ram.c          | 204 ---------------------------------------
 3 files changed, 208 insertions(+), 204 deletions(-)
migration/ram-compress.c +203 -0
index 77902a1d65..f75b8c3079 100644
@@ -47,6 +47,24 @@ static QemuThread *compress_threads;
 static QemuMutex comp_done_lock;
 static QemuCond comp_done_cond;
 
+struct DecompressParam {
+    bool done;
+    bool quit;
+    QemuMutex mutex;
+    QemuCond cond;
+    void *des;
+    uint8_t *compbuf;
+    int len;
+    z_stream stream;
+};
+typedef struct DecompressParam DecompressParam;
+
+static QEMUFile *decomp_file;
+static DecompressParam *decomp_param;
+static QemuThread *decompress_threads;
+static QemuMutex decomp_done_lock;
+static QemuCond decomp_done_cond;
+
 static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
                                            RAMBlock *block, ram_addr_t offset,
                                            uint8_t *source_buf);
@@ -271,3 +289,188 @@ retry:
 
     return pages;
 }
+
+/* return the size after decompression, or negative value on error */
+static int
+qemu_uncompress_data(z_stream *stream, uint8_t *dest, size_t dest_len,
+                     const uint8_t *source, size_t source_len)
+{
+    int err;
+
+    err = inflateReset(stream);
+    if (err != Z_OK) {
+        return -1;
+    }
+
+    stream->avail_in = source_len;
+    stream->next_in = (uint8_t *)source;
+    stream->avail_out = dest_len;
+    stream->next_out = dest;
+
+    err = inflate(stream, Z_NO_FLUSH);
+    if (err != Z_STREAM_END) {
+        return -1;
+    }
+
+    return stream->total_out;
+}
+
+static void *do_data_decompress(void *opaque)
+{
+    DecompressParam *param = opaque;
+    unsigned long pagesize;
+    uint8_t *des;
+    int len, ret;
+
+    qemu_mutex_lock(&param->mutex);
+    while (!param->quit) {
+        if (param->des) {
+            des = param->des;
+            len = param->len;
+            param->des = 0;
+            qemu_mutex_unlock(&param->mutex);
+
+            pagesize = TARGET_PAGE_SIZE;
+
+            ret = qemu_uncompress_data(&param->stream, des, pagesize,
+                                       param->compbuf, len);
+            if (ret < 0 && migrate_get_current()->decompress_error_check) {
+                error_report("decompress data failed");
+                qemu_file_set_error(decomp_file, ret);
+            }
+
+            qemu_mutex_lock(&decomp_done_lock);
+            param->done = true;
+            qemu_cond_signal(&decomp_done_cond);
+            qemu_mutex_unlock(&decomp_done_lock);
+
+            qemu_mutex_lock(&param->mutex);
+        } else {
+            qemu_cond_wait(&param->cond, &param->mutex);
+        }
+    }
+    qemu_mutex_unlock(&param->mutex);
+
+    return NULL;
+}
+
+int wait_for_decompress_done(void)
+{
+    int idx, thread_count;
+
+    if (!migrate_use_compression()) {
+        return 0;
+    }
+
+    thread_count = migrate_decompress_threads();
+    qemu_mutex_lock(&decomp_done_lock);
+    for (idx = 0; idx < thread_count; idx++) {
+        while (!decomp_param[idx].done) {
+            qemu_cond_wait(&decomp_done_cond, &decomp_done_lock);
+        }
+    }
+    qemu_mutex_unlock(&decomp_done_lock);
+    return qemu_file_get_error(decomp_file);
+}
+
+void compress_threads_load_cleanup(void)
+{
+    int i, thread_count;
+
+    if (!migrate_use_compression()) {
+        return;
+    }
+    thread_count = migrate_decompress_threads();
+    for (i = 0; i < thread_count; i++) {
+        /*
+         * we use it as a indicator which shows if the thread is
+         * properly init'd or not
+         */
+        if (!decomp_param[i].compbuf) {
+            break;
+        }
+
+        qemu_mutex_lock(&decomp_param[i].mutex);
+        decomp_param[i].quit = true;
+        qemu_cond_signal(&decomp_param[i].cond);
+        qemu_mutex_unlock(&decomp_param[i].mutex);
+    }
+    for (i = 0; i < thread_count; i++) {
+        if (!decomp_param[i].compbuf) {
+            break;
+        }
+
+        qemu_thread_join(decompress_threads + i);
+        qemu_mutex_destroy(&decomp_param[i].mutex);
+        qemu_cond_destroy(&decomp_param[i].cond);
+        inflateEnd(&decomp_param[i].stream);
+        g_free(decomp_param[i].compbuf);
+        decomp_param[i].compbuf = NULL;
+    }
+    g_free(decompress_threads);
+    g_free(decomp_param);
+    decompress_threads = NULL;
+    decomp_param = NULL;
+    decomp_file = NULL;
+}
+
+int compress_threads_load_setup(QEMUFile *f)
+{
+    int i, thread_count;
+
+    if (!migrate_use_compression()) {
+        return 0;
+    }
+
+    thread_count = migrate_decompress_threads();
+    decompress_threads = g_new0(QemuThread, thread_count);
+    decomp_param = g_new0(DecompressParam, thread_count);
+    qemu_mutex_init(&decomp_done_lock);
+    qemu_cond_init(&decomp_done_cond);
+    decomp_file = f;
+    for (i = 0; i < thread_count; i++) {
+        if (inflateInit(&decomp_param[i].stream) != Z_OK) {
+            goto exit;
+        }
+
+        decomp_param[i].compbuf = g_malloc0(compressBound(TARGET_PAGE_SIZE));
+        qemu_mutex_init(&decomp_param[i].mutex);
+        qemu_cond_init(&decomp_param[i].cond);
+        decomp_param[i].done = true;
+        decomp_param[i].quit = false;
+        qemu_thread_create(decompress_threads + i, "decompress",
+                           do_data_decompress, decomp_param + i,
+                           QEMU_THREAD_JOINABLE);
+    }
+    return 0;
+exit:
+    compress_threads_load_cleanup();
+    return -1;
+}
+
+void decompress_data_with_multi_threads(QEMUFile *f, void *host, int len)
+{
+    int idx, thread_count;
+
+    thread_count = migrate_decompress_threads();
+    QEMU_LOCK_GUARD(&decomp_done_lock);
+    while (true) {
+        for (idx = 0; idx < thread_count; idx++) {
+            if (decomp_param[idx].done) {
+                decomp_param[idx].done = false;
+                qemu_mutex_lock(&decomp_param[idx].mutex);
+                qemu_get_buffer(f, decomp_param[idx].compbuf, len);
+                decomp_param[idx].des = host;
+                decomp_param[idx].len = len;
+                qemu_cond_signal(&decomp_param[idx].cond);
+                qemu_mutex_unlock(&decomp_param[idx].mutex);
+                break;
+            }
+        }
+        if (idx < thread_count) {
+            break;
+        } else {
+            qemu_cond_wait(&decomp_done_cond, &decomp_done_lock);
+        }
+    }
+}
migration/ram-compress.h +5 -0
index 06570a799c..6f7fe2f472 100644
@@ -62,4 +62,9 @@ void flush_compressed_data(int (send_queued_data(CompressParam *)));
 int compress_page_with_multi_thread(RAMBlock *block, ram_addr_t offset,
                                 int (send_queued_data(CompressParam *)));
 
+int wait_for_decompress_done(void);
+void compress_threads_load_cleanup(void);
+int compress_threads_load_setup(QEMUFile *f);
+void decompress_data_with_multi_threads(QEMUFile *f, void *host, int len);
+
 #endif
migration/ram.c +0 -204

216 lines not on this page · raw message

--
2.30.2

#20 lore raw
In reply to Lukas Straub
Quoted 12 lines

-----Original Message-----
From: [email protected] <qemu- [email protected]> On Behalf Of Lukas Straub
Sent: Monday, April 3, 2023 1:56 AM
To: qemu-devel <[email protected]>
Cc: Dr. David Alan Gilbert <[email protected]>; Juan Quintela <[email protected]>; Peter Xu <[email protected]>
Subject: [PATCH 00/14] migration/ram.c: Refactor compress code

Quoted 7 lines

This series refactors the ram compress code.

It first removes ram.c dependencies from the core compress code, then moves it out to its own file. Finally, on the migration destination side the initialisation and cleanup of compress threads is moved out of ram.c to migration.c. This allows using COLO with compress enabled.

Nice to see this optimization~
Support the ram compress feature will reduce COLO checkpoint network bandwidth requirements And may improve COLO protected VM's performance.

Thanks
Chen

Quoted 35 lines

This series is based on the following series:
https://lore.kernel.org/qemu-
devel/af76761aa6978071c5b8e9b872b697db465a5520.1680457631.git.lukasstr [email protected]/T/#t

Lukas Straub (14):
ram.c: Let the compress threads return a CompressResult enum ram.c: Dont change param->block in the compress thread ram.c: Reset result after sending queued data
ram.c: Do not call save_page_header() from compress threads ram.c: Call update_compress_thread_counts from
compress_send_queued_data
ram.c: Remove last ram.c dependency from the core compress code ram.c: Introduce whitespace (squash with next patch) ram.c: Move core compression code into its own file ram.c: Remove whitespace (squash with previous patch) ram.c: Move core decompression code into its own file ram compress: Assert that the file buffer matches the result ram.c: Remove unused include after moving out code ram-compress.c: Make target independent
migration: Initialize and cleanup decompression in migration.c

 migration/meson.build    |   5 +-
 migration/migration.c    |   9 +
 migration/qemu-file.c    |  11 +
 migration/qemu-file.h    |   1 +
 migration/ram-compress.c | 483
++++++++++++++++++++++++++++++++++++++
 migration/ram-compress.h |  70 ++++++
 migration/ram.c          | 490 +++------------------------------------
 7 files changed, 615 insertions(+), 454 deletions(-)  create mode 100644

migration/ram-compress.c create mode 100644 migration/ram-compress.h

--
2.30.2

#2 lore raw

Re: [PATCH 01/14] ram.c: Let the compress threads return a CompressResult enum

In reply to Lukas Straub
Quoted 13 lines · Lukas Straub

This will be used in the next commits to move save_page_header() out of compress code.

---
  migration/ram.c | 34 ++++++++++++++++++++++------------
  1 file changed, 22 insertions(+), 12 deletions(-)
migration/ram.c +0 -0
index 9d1817ab7b..ca561e62bd 100644

migration/ram.c MigrationOps *migration_ops; · line 497

Quoted 5 lines
migration/ram.c +2 -0
@@ -493,10 +493,17 @@ MigrationOps *migration_ops;
 
  CompressionStats compression_counters;
 
+enum CompressResult {
+    RES_NONE = 0,

What about RES_INVALID?

Quoted 21 lines
migration/ram.c +8 -3
+    RES_ZEROPAGE = 1,
+    RES_COMPRESS = 2
+};
 
 
-static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
-                                 ram_addr_t offset, uint8_t *source_buf)
+static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
+                                           RAMBlock *block, ram_addr_t offset,
+                                           uint8_t *source_buf)
  {
 
 
      if (ret < 0) {
          qemu_file_set_error(migrate_get_current()->to_dst_file, ret);
          error_report("compressed data failed!");
+        return RES_NONE;
      }
-    return false;
+    return RES_COMPRESS;
  }
Reviewed-by on v1 10/14
#13 lore raw

Re: [PATCH 10/14] ram.c: Move core decompression code into its own file

In reply to Lukas Straub
Quoted 8 lines · Lukas Straub

No functional changes intended.

---
  migration/ram-compress.c | 203 ++++++++++++++++++++++++++++++++++++++
  migration/ram-compress.h |   5 +
  migration/ram.c          | 204 ---------------------------------------
  3 files changed, 208 insertions(+), 204 deletions(-)
#16 lore raw

Re: [PATCH 12/14] ram.c: Remove unused include after moving out code

In reply to Lukas Straub
Quoted 10 lines · Lukas Straub
---
  migration/ram.c | 1 -
  1 file changed, 1 deletion(-)
migration/ram.c +0 -0
index 7a8f540737..9072d70f7c 100644

migration/ram.c line 35

Quoted 4 lines
migration/ram.c +0 -1
@@ -32,7 +32,6 @@
  #include "qemu/bitmap.h"
  #include "qemu/madvise.h"
  #include "qemu/main-loop.h"
-#include "io/channel-null.h"

To squash with patch #8 "ram.c: Move core compression code into its own file".

#3 lore raw

Re: [PATCH 01/14] ram.c: Let the compress threads return a CompressResult enum

In reply to Philippe Mathieu-Daudé
Quoted 15 lines · On Mon, 3 Apr 2023 09:25:41 +0200 Philippe Mathieu-Daudé <[email protected]>…
Quoted 14 lines · Lukas Straub

This will be used in the next commits to move save_page_header() out of compress code.

---
  migration/ram.c | 34 ++++++++++++++++++++++------------
  1 file changed, 22 insertions(+), 12 deletions(-)
migration/ram.c +0 -0
index 9d1817ab7b..ca561e62bd 100644
@@ -493,10 +493,17 @@ MigrationOps *migration_ops;
 
Quoted 6 lines

migration/ram.c MigrationOps *migration_ops; · line 497

Quoted 4 lines
migration/ram.c +2 -0
  CompressionStats compression_counters;
 
+enum CompressResult {
+    RES_NONE = 0,  

What about RES_INVALID?

I think RES_NONE is more accurate, because having no result is a common case. The submit side first handles the result from a previous compression and then submits the new compression request. And for example, when submitting the very first request to the thread there won't be a previous result. Or when submitting after the threads where flushed.

I just opted to return RES_NONE on error, because it seems more correct.

Quoted 22 lines
Quoted 21 lines
migration/ram.c +8 -3
+    RES_ZEROPAGE = 1,
+    RES_COMPRESS = 2
+};  
 
 
-static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,
-                                 ram_addr_t offset, uint8_t *source_buf)
+static CompressResult do_compress_ram_page(QEMUFile *f, z_stream *stream,
+                                           RAMBlock *block, ram_addr_t offset,
+                                           uint8_t *source_buf)
  {  
 
 
      if (ret < 0) {
          qemu_file_set_error(migrate_get_current()->to_dst_file, ret);
          error_report("compressed data failed!");
+        return RES_NONE;
      }
-    return false;
+    return RES_COMPRESS;
  }  
#21 lore raw
In reply to Lukas Straub
Quoted 10 lines · On Sun, 2 Apr 2023 17:55:59 +0000 Lukas Straub <[email protected]> wrote:

This series refactors the ram compress code.

It first removes ram.c dependencies from the core compress code, then moves it out to its own file. Finally, on the migration destination side the initialisation and cleanup of compress threads is moved out of ram.c to migration.c. This allows using COLO with compress enabled.

This series is based on the following series:
https://lore.kernel.org/qemu-devel/af76761aa6978071c5b8e9b872b697db465a5520.1680457631.git.lukasstraub2@web.de/T/#t

Hmm, I'm wondering if I should add postcopy+compress tests in this series? Because if we start this, the test matrix really will explode.

Regards,
Lukas Straub

#22 lore raw
Quoted 10 lines · Lukas Straub
Quoted 7 lines · On Sun, 2 Apr 2023 17:55:59 +0000 Lukas Straub <[email protected]> wrote:

This series refactors the ram compress code.

It first removes ram.c dependencies from the core compress code, then moves it out to its own file. Finally, on the migration destination side the initialisation and cleanup of compress threads is moved out of ram.c to migration.c. This allows using COLO with compress enabled.

Quoted 6 lines
Quoted 3 lines

This series is based on the following series:
https://lore.kernel.org/qemu-devel/af76761aa6978071c5b8e9b872b697db465a5520.1680457631.git.lukasstraub2@web.de/T/#t

Hmm, I'm wondering if I should add postcopy+compress tests in this series? Because if we start this, the test matrix really will explode.

Do you perhaps mean when compress added to the existing (and already large) postcopy test matrix?

I assume we can still add one for vanilla postcopy+compress, so it still covers the major parts. Or, add the compress test with the postcopy test with most features enabled? The most comprehensive one in qtest should be:

/x86_64/migration/postcopy/preempt/recovery/tls/psk

That covers postcopy+preempt+tls, meanwhile there'll be an emulation of network failure too during postcopy and test recovering from it.

Signature · 1 line
Peter Xu