Migration 20230213 patches
Subsystems (3)
From: Juan Quintela <[email protected]>
The following changes since commit 3b33ae48ec28e1e0d1bc28a85c7423724bcb1a2c:
Merge tag 'block-pull-request' of https://gitlab.com/stefanha/qemu into staging (2023-02-09 15:29:14 +0000)
are available in the Git repository at:
https://gitlab.com/juan.quintela/qemu.git tags/migration-20230213-pull-request
for you to fetch changes up to 24f3e8188c13e5a8b9ad6f2a353f7d0cf80f461c:
ram: Document migration ram flags (2023-02-13 02:58:26 +0100)
----------------------------------------------------------------
Migration Pull request (take2)
Hi
In this PULL request:
- rebase to latest upstream
- fix compilation of linux-user (if have_system was missing) (me)
- cleanup multifd_load_cleanup(leonardo)
- Document RAM flags (me)
Please apply.
[take 1]
This are all the reviewed patches for migration:
- AVX512 support for xbzrle (Ling Xu)
- /dev/userfaultd support (Peter Xu)
- Improve ordering of channels (Peter Xu)
- multifd cleanups (Li Zhang)
- Remove spurious files from last merge (me) Rebase makes that to you
- Fix mixup between state_pending_{exact,estimate} (me)
- Cache RAM size during migration (me)
- cleanup several functions (me)
Please apply.
----------------------------------------------------------------
Juan Quintela (8):
migration: Remove spurious files
migration: Simplify ram_find_and_save_block()
migration: Make find_dirty_block() return a single parameter
migration: Split ram_bytes_total_common() in two functions
migration: Calculate ram size once
migration: Make ram_save_target_page() a pointer
migration: I messed state_pending_exact/estimate
ram: Document migration ram flags
Leonardo Bras (4):
migration/multifd: Change multifd_load_cleanup() signature and usage migration/multifd: Remove unnecessary assignment on
multifd_load_cleanup()
migration/multifd: Join all multifd threads in order to avoid leaks migration/multifd: Move load_cleanup inside incoming_state_destroy
Li Zhang (2):
multifd: cleanup the function multifd_channel_connect
multifd: Remove some redundant code
Peter Xu (6):
linux-headers: Update to v6.1
util/userfaultfd: Support /dev/userfaultfd
migration: Rework multi-channel checks on URI
migration: Cleanup postcopy_preempt_setup()
migration: Add a semaphore to count PONGs
migration: Postpone postcopy preempt channel to be after main
ling xu (2):
AVX512 support for xbzrle_encode_buffer
Update bench-code for addressing CI problem
.../x86_64-quintela-devices.mak | 7 - .../x86_64-quintela2-devices.mak | 6 - meson.build | 17 + include/standard-headers/drm/drm_fourcc.h | 34 +- include/standard-headers/linux/ethtool.h | 63 +- include/standard-headers/linux/fuse.h | 6 +- .../linux/input-event-codes.h | 1 + include/standard-headers/linux/virtio_blk.h | 19 + linux-headers/asm-generic/hugetlb_encode.h | 26 +- linux-headers/asm-generic/mman-common.h | 2 + linux-headers/asm-mips/mman.h | 2 + linux-headers/asm-riscv/kvm.h | 4 + linux-headers/linux/kvm.h | 1 + linux-headers/linux/psci.h | 14 + linux-headers/linux/userfaultfd.h | 4 + linux-headers/linux/vfio.h | 142 ++ migration/migration.h | 15 +- migration/multifd.h | 3 +- migration/postcopy-ram.h | 4 +- migration/xbzrle.h | 4 + migration/migration.c | 138 +- migration/multifd.c | 87 +- migration/postcopy-ram.c | 31 +- migration/ram.c | 148 +- migration/savevm.c | 56 +- migration/xbzrle.c | 124 ++ tests/bench/xbzrle-bench.c | 469 ++++++ tests/unit/test-xbzrle.c | 39 +- util/userfaultfd.c | 32 + meson_options.txt | 2 + migration/multifd.c.orig | 1274 ----------------- scripts/meson-buildoptions.sh | 3 + tests/bench/meson.build | 6 + util/trace-events | 1 + 34 files changed, 1278 insertions(+), 1506 deletions(-) delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela-devices.mak delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela2-devices.mak create mode 100644 tests/bench/xbzrle-bench.c delete mode 100644 migration/multifd.c.orig
Signature · 1 line
2.39.1
[PULL 02/22] multifd: cleanup the function multifd_channel_connect
From: Li Zhang <[email protected]>
Cleanup multifd_channel_connect
--- migration/multifd.c | 43 +++++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 22 deletions(-)
migration/multifd.c +21 -22
@@ -843,30 +843,29 @@ static bool multifd_channel_connect(MultiFDSendParams *p, ioc,object_get_typename (OBJECT (ioc)), migrate_get_current()->hostname, error); -if (!error) { -if (migrate_channel_requires_tls_upgrade (ioc)) { -multifd_tls_channel_connect (p, ioc, &error); -if (!error) { -/* -* tls_channel_connect will call back to this -* function after the TLS handshake, -* so we mustn't call multifd_send_thread until then -*/ -return true; - }else { -return false; - } +if (error) { +return false; + } +if (migrate_channel_requires_tls_upgrade (ioc)) { +multifd_tls_channel_connect (p, ioc, &error); +if (!error) { +/* +* tls_channel_connect will call back to this +* function after the TLS handshake, +* so we mustn't call multifd_send_thread until then +*/ +return true; }else { -migration_ioc_register_yank (ioc); - p->registered_yank = true; - p->c = ioc; -qemu_thread_create (&p->thread, p->name, multifd_send_thread, p, -QEMU_THREAD_JOINABLE ); - } -return true; +return false; + } + }else { +migration_ioc_register_yank (ioc); + p->registered_yank = true; + p->c = ioc; +qemu_thread_create (&p->thread, p->name, multifd_send_thread, p, +QEMU_THREAD_JOINABLE ); } - -return false; +return true; } static void multifd_new_send_channel_cleanup(MultiFDSendParams *p,
Signature · 1 line
2.39.1
[PULL 08/22] migration: Split ram_bytes_total_common() in two functions
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
It is just a big if in the middle of the function, and we need two functions anways.
---
Reindent to make Phillipe happy (and CODING_STYLE)
--- migration/ram.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-)
migration/ram.c +14 -11
@@ -2601,28 +2601,30 @@ void acct_update_position(QEMUFile *f, size_t size, bool zero) } } -static uint64_t ram_bytes_total_common (bool count_ignored) +static uint64_t ram_bytes_total_with_ignored (void ) {RAMBlock *block;uint64_t total =0 ;RCU_READ_LOCK_GUARD (); -if (count_ignored) { -RAMBLOCK_FOREACH_MIGRATABLE (block) { - total += block->used_length; - } - }else { -RAMBLOCK_FOREACH_NOT_IGNORED (block) { - total += block->used_length; - } +RAMBLOCK_FOREACH_MIGRATABLE (block) { + total += block->used_length; }return total; }uint64_t ram_bytes_total (void ) { -return ram_bytes_total_common (false); +RAMBlock *block; +uint64_t total =0 ; + +RCU_READ_LOCK_GUARD (); + +RAMBLOCK_FOREACH_NOT_IGNORED (block) { + total += block->used_length; + } +return total; }static void xbzrle_load_setup (void )
@@ -3227,7 +3229,8 @@ static int ram_save_setup(QEMUFile *f, void *opaque) (*rsp)->pss[RAM_CHANNEL_PRECOPY ].pss_channel = f; WITH_RCU_READ_LOCK_GUARD() { -qemu_put_be64 (f,ram_bytes_total_common (true) |RAM_SAVE_FLAG_MEM_SIZE ); +qemu_put_be64 (f,ram_bytes_total_with_ignored () + |RAM_SAVE_FLAG_MEM_SIZE );RAMBLOCK_FOREACH_MIGRATABLE (block) {qemu_put_byte (f,strlen (block->idstr));
Signature · 1 line
2.39.1
[PULL 15/22] migration: Cleanup postcopy_preempt_setup()
In reply to Xxx XxFrom: Peter Xu <[email protected]>
Since we just dropped the only case where postcopy_preempt_setup() can return an error, it doesn't need a retval anymore because it never fails. Move the preempt check to the caller, preparing it to be used elsewhere to do nothing but as simple as kicking the async connection.
--- migration/postcopy-ram.h | 2 +- migration/migration.c | 8 ++------ migration/postcopy-ram.c | 8 +------- 3 files changed, 4 insertions(+), 14 deletions(-)
migration/postcopy-ram.h +1 -1
@@ -191,7 +191,7 @@ enum PostcopyChannels { };void postcopy_preempt_new_channel (MigrationIncomingState *mis,QEMUFile *file); -int postcopy_preempt_setup (MigrationState *s,Error **errp); +void postcopy_preempt_setup (MigrationState *s);int postcopy_preempt_wait_channel (MigrationState *s);#endif
migration/migration.c +2 -6
@@ -4347,12 +4347,8 @@ void migrate_fd_connect(MigrationState *s, Error *error_in) }/* This needs to be done before resuming a postcopy */ -if (postcopy_preempt_setup (s, &local_err)) { -error_report_err (local_err); -migrate_set_state (&s->state,MIGRATION_STATUS_SETUP , -MIGRATION_STATUS_FAILED ); -migrate_fd_cleanup (s); -return ; +if (migrate_postcopy_preempt ()) { +postcopy_preempt_setup (s); }if (resume) {
migration/postcopy-ram.c +1 -7
@@ -1629,16 +1629,10 @@ int postcopy_preempt_wait_channel(MigrationState *s)return s->postcopy_qemufile_src ?0 :-1 ; } -int postcopy_preempt_setup (MigrationState *s,Error **errp) +void postcopy_preempt_setup (MigrationState *s) { -if (!migrate_postcopy_preempt ()) { -return 0 ; - } -/* Kick an async task to connect */ socket_send_channel_create (postcopy_preempt_send_channel_new, s); - -return 0 ; }static void postcopy_pause_ram_fast_load (MigrationIncomingState *mis)
Signature · 1 line
2.39.1
[PULL 01/22] migration: Remove spurious files
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
I introduced spurious files on my tree during a rebase:
commit ebfc57871506b3fe36cc41f69ee3ad31a34afd63
Author: Zhenzhong Duan <[email protected]> Date: Mon Oct 17 15:53:51 2022 +0800
multifd: Fix flush of zero copy page send request
Make IO channel flush call after the inflight request has been drained in multifd thread, or else we may missed to flush the inflight request.
To make things worse, it appears like Zhenzhong is the one to blame.
for(int i=0; i < 1000000; i++) {
printf("I will not do rebases when I am tired\n");
}Sorry, Juan.
--- .../x86_64-quintela-devices.mak | 7 - .../x86_64-quintela2-devices.mak | 6 - migration/multifd.c.orig | 1274 ----------------- 3 files changed, 1287 deletions(-) delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela-devices.mak delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela2-devices.mak delete mode 100644 migration/multifd.c.orig
configs/devices/x86_64-softmmu/x86_64-quintela-devices.mak deleted +0 -7
@@ -1,7 +0,0 @@ -# Boards: -# -CONFIG_ISAPC=n -CONFIG_I440FX=n -CONFIG_Q35=n -CONFIG_MICROVM=y -
configs/devices/x86_64-softmmu/x86_64-quintela2-devices.mak deleted +0 -6
@@ -1,6 +0,0 @@ -# Boards: -# -CONFIG_ISAPC=y -CONFIG_I440FX=y -CONFIG_Q35=y -CONFIG_MICROVM=y
migration/multifd.c.orig deleted +0 -1274
1,274 lines not on this page · raw message
Signature · 1 line
2.39.1
[PULL 03/22] multifd: Remove some redundant code
In reply to Xxx XxFrom: Li Zhang <[email protected]>
Clean up some unnecessary code
--- migration/multifd.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-)
migration/multifd.c +4 -11
@@ -892,19 +892,15 @@ static void multifd_new_send_channel_async(QIOTask *task, gpointer opaque)Error *local_err =NULL ;trace_multifd_new_send_channel_async (p->id); -if (qio_task_propagate_error (task, &local_err)) { - goto cleanup; - }else { +if (!qio_task_propagate_error (task, &local_err)) { p->c =QIO_CHANNEL (sioc);qio_channel_set_delay (p->c, false); p->running = true; -if (!multifd_channel_connect (p, sioc, local_err)) { - goto cleanup; +if (multifd_channel_connect (p, sioc, local_err)) { +return ; } -return ; } -cleanup:multifd_new_send_channel_cleanup (p, sioc, local_err); }
@@ -1115,10 +1111,7 @@ static void *multifd_recv_thread(void *opaque) ret =qio_channel_read_all_eof (p->c, (void *)p->packet, p->packet_len, &local_err); -if (ret ==0 ) {/* EOF */ -break ; - } -if (ret ==-1 ) {/* Error */ +if (ret ==0 || ret ==-1 ) {/* 0: EOF -1: Error */ break ; }
Signature · 1 line
2.39.1
[PULL 04/22] linux-headers: Update to v6.1
In reply to Xxx XxFrom: Peter Xu <[email protected]>
--- include/standard-headers/drm/drm_fourcc.h | 34 ++++- include/standard-headers/linux/ethtool.h | 63 +++++++- include/standard-headers/linux/fuse.h | 6 +- .../linux/input-event-codes.h | 1 + include/standard-headers/linux/virtio_blk.h | 19 +++ linux-headers/asm-generic/hugetlb_encode.h | 26 ++-- linux-headers/asm-generic/mman-common.h | 2 + linux-headers/asm-mips/mman.h | 2 + linux-headers/asm-riscv/kvm.h | 4 + linux-headers/linux/kvm.h | 1 + linux-headers/linux/psci.h | 14 ++ linux-headers/linux/userfaultfd.h | 4 + linux-headers/linux/vfio.h | 142 ++++++++++++++++++ 13 files changed, 298 insertions(+), 20 deletions(-)
include/standard-headers/drm/drm_fourcc.h +30 -4
@@ -98,18 +98,42 @@ extern "C" {#define DRM_FORMAT_INVALID 0/* color index */ +#define DRM_FORMAT_C1 fourcc_code('C', '1', ' ', ' ')/* [7:0] C0:C1:C2:C3:C4:C5:C6:C7 1:1:1:1:1:1:1:1 eight pixels/byte */ +#define DRM_FORMAT_C2 fourcc_code('C', '2', ' ', ' ')/* [7:0] C0:C1:C2:C3 2:2:2:2 four pixels/byte */ +#define DRM_FORMAT_C4 fourcc_code('C', '4', ' ', ' ')/* [7:0] C0:C1 4:4 two pixels/byte */ #define DRM_FORMAT_C8 fourcc_code('C', '8', ' ', ' ')/* [7:0] C */ -/* 8 bpp Red */ +/* 1 bpp Darkness (inverse relationship between channel value and brightness) */ +#define DRM_FORMAT_D1 fourcc_code('D', '1', ' ', ' ')/* [7:0] D0:D1:D2:D3:D4:D5:D6:D7 1:1:1:1:1:1:1:1 eight pixels/byte */ + +/* 2 bpp Darkness (inverse relationship between channel value and brightness) */ +#define DRM_FORMAT_D2 fourcc_code('D', '2', ' ', ' ')/* [7:0] D0:D1:D2:D3 2:2:2:2 four pixels/byte */ + +/* 4 bpp Darkness (inverse relationship between channel value and brightness) */ +#define DRM_FORMAT_D4 fourcc_code('D', '4', ' ', ' ')/* [7:0] D0:D1 4:4 two pixels/byte */ + +/* 8 bpp Darkness (inverse relationship between channel value and brightness) */ +#define DRM_FORMAT_D8 fourcc_code('D', '8', ' ', ' ')/* [7:0] D */ + +/* 1 bpp Red (direct relationship between channel value and brightness) */ +#define DRM_FORMAT_R1 fourcc_code('R', '1', ' ', ' ')/* [7:0] R0:R1:R2:R3:R4:R5:R6:R7 1:1:1:1:1:1:1:1 eight pixels/byte */ + +/* 2 bpp Red (direct relationship between channel value and brightness) */ +#define DRM_FORMAT_R2 fourcc_code('R', '2', ' ', ' ')/* [7:0] R0:R1:R2:R3 2:2:2:2 four pixels/byte */ + +/* 4 bpp Red (direct relationship between channel value and brightness) */ +#define DRM_FORMAT_R4 fourcc_code('R', '4', ' ', ' ')/* [7:0] R0:R1 4:4 two pixels/byte */ + +/* 8 bpp Red (direct relationship between channel value and brightness) */ #define DRM_FORMAT_R8 fourcc_code('R', '8', ' ', ' ')/* [7:0] R */ -/* 10 bpp Red */ +/* 10 bpp Red (direct relationship between channel value and brightness) */ #define DRM_FORMAT_R10 fourcc_code('R', '1', '0', ' ')/* [15:0] x:R 6:10 little endian */ -/* 12 bpp Red */ +/* 12 bpp Red (direct relationship between channel value and brightness) */ #define DRM_FORMAT_R12 fourcc_code('R', '1', '2', ' ')/* [15:0] x:R 4:12 little endian */ -/* 16 bpp Red */ +/* 16 bpp Red (direct relationship between channel value and brightness) */ #define DRM_FORMAT_R16 fourcc_code('R', '1', '6', ' ')/* [15:0] R little endian */ /* 16 bpp RG */
@@ -204,7 +228,9 @@ extern "C" {#define DRM_FORMAT_VYUY fourcc_code('V', 'Y', 'U', 'Y')/* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */ #define DRM_FORMAT_AYUV fourcc_code('A', 'Y', 'U', 'V')/* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */ +#define DRM_FORMAT_AVUY8888 fourcc_code('A', 'V', 'U', 'Y')/* [31:0] A:Cr:Cb:Y 8:8:8:8 little endian */ #define DRM_FORMAT_XYUV8888 fourcc_code('X', 'Y', 'U', 'V')/* [31:0] X:Y:Cb:Cr 8:8:8:8 little endian */ +#define DRM_FORMAT_XVUY8888 fourcc_code('X', 'V', 'U', 'Y')/* [31:0] X:Cr:Cb:Y 8:8:8:8 little endian */ #define DRM_FORMAT_VUY888 fourcc_code('V', 'U', '2', '4')/* [23:0] Cr:Cb:Y 8:8:8 little endian */ #define DRM_FORMAT_VUY101010 fourcc_code('V', 'U', '3', '0')/* Y followed by U then V, 10:10:10. Non-linear modifier only */
include/standard-headers/linux/ethtool.h +61 -2
88 lines not on this page · raw message
include/standard-headers/linux/fuse.h +5 -1
@@ -194,6 +194,9 @@* - add FUSE_SECURITY_CTX init flag * - add security context to create, mkdir, symlink, and mknod requests * - add FUSE_HAS_INODE_DAX, FUSE_ATTR_DAX +* +* 7.37 +* - add FUSE_TMPFILE */ #ifndef _LINUX_FUSE_H
@@ -225,7 +228,7 @@#define FUSE_KERNEL_VERSION 7/** Minor version number of this interface */ -#define FUSE_KERNEL_MINOR_VERSION 36 +#define FUSE_KERNEL_MINOR_VERSION 37/** The node ID of the root inode */ #define FUSE_ROOT_ID 1
@@ -533,6 +536,7 @@ enum fuse_opcode {FUSE_SETUPMAPPING =48 ,FUSE_REMOVEMAPPING =49 ,FUSE_SYNCFS =50 , +FUSE_TMPFILE =51 ,/* CUSE specific operations */ CUSE_INIT = 4096,
include/standard-headers/linux/input-event-codes.h +1 -0
@@ -862,6 +862,7 @@#define ABS_TOOL_WIDTH 0x1c#define ABS_VOLUME 0x20 +#define ABS_PROFILE 0x21#define ABS_MISC 0x28
include/standard-headers/linux/virtio_blk.h +19 -0
@@ -40,6 +40,7 @@#define VIRTIO_BLK_F_MQ 12/* support more than one vq */ #define VIRTIO_BLK_F_DISCARD 13/* DISCARD is supported */ #define VIRTIO_BLK_F_WRITE_ZEROES 14/* WRITE ZEROES is supported */ +#define VIRTIO_BLK_F_SECURE_ERASE 16/* Secure Erase is supported */ /* Legacy feature bits */ #ifndef VIRTIO_BLK_NO_LEGACY
@@ -119,6 +120,21 @@ struct virtio_blk_config {uint8_t write_zeroes_may_unmap;uint8_t unused1[3 ]; + +/* the next 3 entries are guarded by VIRTIO_BLK_F_SECURE_ERASE */ +/* +* The maximum secure erase sectors (in 512-byte sectors) for +* one segment. +*/ +__virtio32 max_secure_erase_sectors; +/* +* The maximum number of secure erase segments in a +* secure erase command. +*/ +__virtio32 max_secure_erase_seg; +/* Secure erase commands must be aligned to this number of sectors. */ +__virtio32 secure_erase_sector_alignment; + }QEMU_PACKED ;/*
@@ -153,6 +169,9 @@ struct virtio_blk_config {/* Write zeroes command */ #define VIRTIO_BLK_T_WRITE_ZEROES 13 +/* Secure erase command */ +#define VIRTIO_BLK_T_SECURE_ERASE 14 +#ifndef VIRTIO_BLK_NO_LEGACY /* Barrier before this op. */ #define VIRTIO_BLK_T_BARRIER 0x80000000
linux-headers/asm-generic/hugetlb_encode.h +13 -13
@@ -20,18 +20,18 @@#define HUGETLB_FLAG_ENCODE_SHIFT 26#define HUGETLB_FLAG_ENCODE_MASK 0x3f -#define HUGETLB_FLAG_ENCODE_16KB (14 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_64KB (16 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_512KB (19 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_1MB (20 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_2MB (21 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_8MB (23 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_16MB (24 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_32MB (25 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_256MB (28 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_512MB (29 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_1GB (30 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_2GB (31 << HUGETLB_FLAG_ENCODE_SHIFT) -#define HUGETLB_FLAG_ENCODE_16GB (34 << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_16KB (14U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_64KB (16U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_512KB (19U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_1MB (20U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_2MB (21U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_8MB (23U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_16MB (24U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_32MB (25U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_256MB (28U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_512MB (29U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_1GB (30U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_2GB (31U << HUGETLB_FLAG_ENCODE_SHIFT) +#define HUGETLB_FLAG_ENCODE_16GB (34U << HUGETLB_FLAG_ENCODE_SHIFT)#endif /* _ASM_GENERIC_HUGETLB_ENCODE_H_ */
linux-headers/asm-generic/mman-common.h +2 -0
@@ -77,6 +77,8 @@#define MADV_DONTNEED_LOCKED 24/* like DONTNEED, but drop locked pages too */ +#define MADV_COLLAPSE 25/* Synchronous hugepage collapse */ +/* compatibility flags */ #define MAP_FILE 0
linux-headers/asm-mips/mman.h +2 -0
@@ -103,6 +103,8 @@#define MADV_DONTNEED_LOCKED 24/* like DONTNEED, but drop locked pages too */ +#define MADV_COLLAPSE 25/* Synchronous hugepage collapse */ +/* compatibility flags */ #define MAP_FILE 0
linux-headers/asm-riscv/kvm.h +4 -0
@@ -48,6 +48,7 @@ struct kvm_sregs {/* CONFIG registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */ struct kvm_riscv_config {unsigned long isa; +unsigned long zicbom_block_size; };/* CORE registers for KVM_GET_ONE_REG and KVM_SET_ONE_REG */
@@ -98,6 +99,9 @@ enum KVM_RISCV_ISA_EXT_ID {KVM_RISCV_ISA_EXT_M ,KVM_RISCV_ISA_EXT_SVPBMT ,KVM_RISCV_ISA_EXT_SSTC , +KVM_RISCV_ISA_EXT_SVINVAL , +KVM_RISCV_ISA_EXT_ZIHINTPAUSE , +KVM_RISCV_ISA_EXT_ZICBOM , KVM_RISCV_ISA_EXT_MAX, };
linux-headers/linux/kvm.h +1 -0
@@ -1175,6 +1175,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_VM_DISABLE_NX_HUGE_PAGES 220#define KVM_CAP_S390_ZPCI_OP 221#define KVM_CAP_S390_CPU_TOPOLOGY 222 +#define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223#ifdef KVM_CAP_IRQ_ROUTING
linux-headers/linux/psci.h +14 -0
@@ -48,12 +48,26 @@#define PSCI_0_2_FN64_MIGRATE_INFO_UP_CPU PSCI_0_2_FN64(7)#define PSCI_1_0_FN_PSCI_FEATURES PSCI_0_2_FN(10) +#define PSCI_1_0_FN_CPU_FREEZE PSCI_0_2_FN(11) +#define PSCI_1_0_FN_CPU_DEFAULT_SUSPEND PSCI_0_2_FN(12) +#define PSCI_1_0_FN_NODE_HW_STATE PSCI_0_2_FN(13)#define PSCI_1_0_FN_SYSTEM_SUSPEND PSCI_0_2_FN(14)#define PSCI_1_0_FN_SET_SUSPEND_MODE PSCI_0_2_FN(15) +#define PSCI_1_0_FN_STAT_RESIDENCY PSCI_0_2_FN(16) +#define PSCI_1_0_FN_STAT_COUNT PSCI_0_2_FN(17) +#define PSCI_1_1_FN_SYSTEM_RESET2 PSCI_0_2_FN(18) +#define PSCI_1_1_FN_MEM_PROTECT PSCI_0_2_FN(19) +#define PSCI_1_1_FN_MEM_PROTECT_CHECK_RANGE PSCI_0_2_FN(19) +#define PSCI_1_0_FN64_CPU_DEFAULT_SUSPEND PSCI_0_2_FN64(12) +#define PSCI_1_0_FN64_NODE_HW_STATE PSCI_0_2_FN64(13)#define PSCI_1_0_FN64_SYSTEM_SUSPEND PSCI_0_2_FN64(14) +#define PSCI_1_0_FN64_STAT_RESIDENCY PSCI_0_2_FN64(16) +#define PSCI_1_0_FN64_STAT_COUNT PSCI_0_2_FN64(17) +#define PSCI_1_1_FN64_SYSTEM_RESET2 PSCI_0_2_FN64(18) +#define PSCI_1_1_FN64_MEM_PROTECT_CHECK_RANGE PSCI_0_2_FN64(19)/* PSCI v0.2 power state encoding for CPU_SUSPEND function */ #define PSCI_0_2_POWER_STATE_ID_MASK 0xffff
linux-headers/linux/userfaultfd.h +4 -0
@@ -12,6 +12,10 @@#include <linux/types.h> +/* ioctls for /dev/userfaultfd */ +#define USERFAULTFD_IOC 0xAA +#define USERFAULTFD_IOC_NEW _IO(USERFAULTFD_IOC, 0x00) +/* * If the UFFDIO_API is upgraded someday, the UFFDIO_UNREGISTER and * UFFDIO_WAKE ioctls should be defined as _IOW and not as _IOR. In
linux-headers/linux/vfio.h +142 -0
148 lines not on this page · raw message
Signature · 1 line
2.39.1
[PULL 05/22] util/userfaultfd: Support /dev/userfaultfd
In reply to Xxx XxFrom: Peter Xu <[email protected]>
Teach QEMU to use /dev/userfaultfd when it existed and fallback to the system call if either it's not there or doesn't have enough permission.
Firstly, as long as the app has permission to access /dev/userfaultfd, it always have the ability to trap kernel faults which QEMU mostly wants. Meanwhile, in some context (e.g. containers) the userfaultfd syscall can be forbidden, so it can be the major way to use postcopy in a restricted environment with strict seccomp setup.
--- util/userfaultfd.c | 32 ++++++++++++++++++++++++++++++++ util/trace-events | 1 + 2 files changed, 33 insertions(+)
util/userfaultfd.c +32 -0
@@ -18,10 +18,42 @@#include <poll.h> #include <sys/syscall.h> #include <sys/ioctl.h> +#include <fcntl.h> + +typedef enum { +UFFD_UNINITIALIZED =0 , +UFFD_USE_DEV_PATH , +UFFD_USE_SYSCALL , +}uffd_open_mode ;int uffd_open (int flags) {#if defined(__NR_userfaultfd) +static uffd_open_mode open_mode; +static int uffd_dev; + +/* Detect how to generate uffd desc when run the 1st time */ +if (open_mode ==UFFD_UNINITIALIZED ) { +/* +* Make /dev/userfaultfd the default approach because it has better +* permission controls, meanwhile allows kernel faults without any +* privilege requirement (e.g. SYS_CAP_PTRACE). +*/ + uffd_dev =open ("/dev/userfaultfd" ,O_RDWR |O_CLOEXEC ); +if (uffd_dev >=0 ) { + open_mode =UFFD_USE_DEV_PATH ; + }else { +/* Fallback to the system call */ + open_mode =UFFD_USE_SYSCALL ; + } +trace_uffd_detect_open_mode (open_mode); + } + +if (open_mode ==UFFD_USE_DEV_PATH ) { +assert (uffd_dev >=0 ); +return ioctl (uffd_dev,USERFAULTFD_IOC_NEW , flags); + } +return syscall (__NR_userfaultfd, flags);#else return -EINVAL ;
util/trace-events +1 -0
@@ -93,6 +93,7 @@ qemu_vfio_region_info(const char *desc, uint64_t region_ofs, uint64_t region_siz qemu_vfio_pci_map_bar(int index, uint64_t region_ofs, uint64_t region_size, int ofs, void *host) "map region bar#%d addr 0x%"PRIx64" size 0x%"PRIx64" ofs 0x%x host %p" #userfaultfd.c +uffd_detect_open_mode(int mode) "%d" uffd_query_features_nosys(int err) "errno: %i" uffd_query_features_api_failed(int err) "errno: %i" uffd_create_fd_nosys(int err) "errno: %i"
Signature · 1 line
2.39.1
[PULL 20/22] migration/multifd: Join all multifd threads in order to avoid leaks
In reply to Xxx XxFrom: Leonardo Bras <[email protected]>
Current approach will only join threads that are still running.
For the threads not joined, resources or private memory are always kept in the process space and never reclaimed before process end, and this risks serious memory leaks.
This should usually not represent a big problem, since multifd migration is usually just ran at most a few times, and after it succeeds there is not much to be done before exiting the process.
Yet still, it should not hurt performance to join all of them.
--- migration/multifd.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
migration/multifd.c +2 -1
@@ -1030,8 +1030,9 @@ void multifd_load_cleanup(void)* however try to wakeup it without harm in cleanup phase. */ qemu_sem_post (&p->sem_sync); -qemu_thread_join (&p->thread); } + +qemu_thread_join (&p->thread); }for (i =0 ; i <migrate_multifd_channels (); i++) {MultiFDRecvParams *p = &multifd_recv_state->params[i];
Signature · 1 line
2.39.1
[PULL 06/22] migration: Simplify ram_find_and_save_block()
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
We will need later that find_dirty_block() return errors, so simplify the loop.
--- migration/ram.c | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-)
migration/ram.c +9 -11
@@ -2542,7 +2542,6 @@ static int ram_find_and_save_block(RAMState *rs) {PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY ];int pages =0 ; -bool again, found;/* No dirty page as there is zero RAM */ if (!ram_bytes_total ()) {
@@ -2564,18 +2563,17 @@ static int ram_find_and_save_block(RAMState *rs)pss_init (pss, rs->last_seen_block, rs->last_page);do { - again = true; - found =get_queued_page (rs, pss); - -if (!found) { +if (!get_queued_page (rs, pss)) {/* priority queue empty, so just search for something dirty */ - found =find_dirty_block (rs, pss, &again); +bool again = true; +if (!find_dirty_block (rs, pss, &again)) { +if (!again) { +break ; + } + } } - -if (found) { - pages =ram_save_host_page (rs, pss); - } - }while (!pages && again); + pages =ram_save_host_page (rs, pss); + }while (!pages); rs->last_seen_block = pss->block; rs->last_page = pss->page;
Signature · 1 line
2.39.1
[PULL 09/22] migration: Calculate ram size once
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
We are recalculating ram size continously, when we know that it don't change during migration. Create a field in RAMState to track it.
--- migration/ram.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
migration/ram.c +5 -2
@@ -330,6 +330,8 @@ struct RAMState {PageSearchStatus pss[RAM_CHANNEL_MAX ];/* UFFD file descriptor, used in 'write-tracking' migration */ int uffdio_fd; +/* total ram size in bytes */ +uint64_t ram_bytes_total;/* Last block that we have visited searching for dirty pages */ RAMBlock *last_seen_block;/* Last dirty target page we have sent */
@@ -2546,7 +2548,7 @@ static int ram_find_and_save_block(RAMState *rs)int pages =0 ;/* No dirty page as there is zero RAM */ -if (!ram_bytes_total ()) { +if (!rs->ram_bytes_total) {return pages; }
@@ -3009,13 +3011,14 @@ static int ram_state_init(RAMState **rsp)qemu_mutex_init (&(*rsp)->bitmap_mutex);qemu_mutex_init (&(*rsp)->src_page_req_mutex);QSIMPLEQ_INIT (&(*rsp)->src_page_requests); + (*rsp)->ram_bytes_total =ram_bytes_total ();/* * Count the total number of pages used by ram blocks not including any * gaps due to alignment or unplugs. * This must match with the initial values of dirty bitmap. */ - (*rsp)->migration_dirty_pages =ram_bytes_total () >>TARGET_PAGE_BITS ; + (*rsp)->migration_dirty_pages = (*rsp)->ram_bytes_total >>TARGET_PAGE_BITS ;ram_state_reset (*rsp);return 0 ;
Signature · 1 line
2.39.1
[PULL 10/22] migration: Make ram_save_target_page() a pointer
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
We are going to create a new function for multifd latest in the series.
--- migration/ram.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-)
migration/ram.c +15 -4
@@ -452,6 +452,13 @@ void dirty_sync_missed_zero_copy(void) ram_counters.dirty_sync_missed_zero_copy++; } +struct MigrationOps { +int (*ram_save_target_page)(RAMState *rs,PageSearchStatus *pss); +}; +typedef struct MigrationOps MigrationOps ; + +MigrationOps *migration_ops; +CompressionStats compression_counters;struct CompressParam {
@@ -2295,14 +2302,14 @@ static bool save_compress_page(RAMState *rs, PageSearchStatus *pss, }/** -* ram_save_target_page: save one target page +* ram_save_target_page_legacy: save one target page * * Returns the number of pages written * * @rs: current RAM state * @pss: data about the page we want to send */ -static int ram_save_target_page (RAMState *rs,PageSearchStatus *pss) +static int ram_save_target_page_legacy (RAMState *rs,PageSearchStatus *pss) {RAMBlock *block = pss->block;ram_addr_t offset = ((ram_addr_t )pss->page) <<TARGET_PAGE_BITS ;
@@ -2428,7 +2435,7 @@ static int ram_save_host_page_urgent(PageSearchStatus *pss)if (page_dirty) {/* Be strict to return code; it must be 1, or what else? */ -if (ram_save_target_page (rs, pss) !=1 ) { +if (migration_ops->ram_save_target_page (rs, pss) !=1 ) {error_report_once ("%s: ram_save_target_page failed" , __func__); ret =-1 ; goto out;
@@ -2497,7 +2504,7 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)if (preempt_active) {qemu_mutex_unlock (&rs->bitmap_mutex); } - tmppages =ram_save_target_page (rs, pss); + tmppages = migration_ops->ram_save_target_page (rs, pss);if (tmppages >=0 ) { pages += tmppages;/*
@@ -2697,6 +2704,8 @@ static void ram_save_cleanup(void *opaque)xbzrle_cleanup ();compress_threads_save_cleanup ();ram_state_cleanup (rsp); +g_free (migration_ops); + migration_ops =NULL ; }static void ram_state_reset (RAMState *rs)
@@ -3252,6 +3261,8 @@ static int ram_save_setup(QEMUFile *f, void *opaque)ram_control_before_iterate (f,RAM_CONTROL_SETUP );ram_control_after_iterate (f,RAM_CONTROL_SETUP ); + migration_ops =g_malloc0 (sizeof (MigrationOps)); + migration_ops->ram_save_target_page = ram_save_target_page_legacy; ret =multifd_send_sync_main (f);if (ret <0 ) {return ret;
Signature · 1 line
2.39.1
[PULL 11/22] migration: I messed state_pending_exact/estimate
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
I called the helper function from the wrong top level function.
This code was introduced in:
commit c8df4a7aeffcb46020f610526eea621fa5b0cd47
Author: Juan Quintela <[email protected]> Date: Mon Oct 3 02:00:03 2022 +0200
migration: Split save_live_pending() into state_pending_*
We split the function into to:
- state_pending_estimate: We estimate the remaining state size without stopping the machine.
- state pending_exact: We calculate the exact amount of remaining state.
Thanks to Avihai Horon <[email protected]> for finding it.
When we introduced that patch, we enden calling
state_pending_estimate() helper from qemu_savevm_statepending_exact() andstate_pending_exact() helper from qemu_savevm_statepending_estimate()
This patch fixes it.
--- migration/savevm.c | 50 +++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 25 deletions(-)
migration/savevm.c +25 -25
@@ -1551,31 +1551,6 @@ void qemu_savevm_state_pending_estimate(uint64_t *res_precopy_only, *res_compatible =0 ; *res_postcopy_only =0 ; - QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { -if (!se->ops || !se->ops->state_pending_exact) { -continue ; - } -if (se->ops->is_active) { -if (!se->ops->is_active (se->opaque)) { -continue ; - } - } - se->ops->state_pending_exact (se->opaque, - res_precopy_only, res_compatible, - res_postcopy_only); - } -} - -void qemu_savevm_state_pending_exact (uint64_t *res_precopy_only, -uint64_t *res_compatible, -uint64_t *res_postcopy_only) -{ -SaveStateEntry *se; - - *res_precopy_only =0 ; - *res_compatible =0 ; - *res_postcopy_only =0 ; - QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {if (!se->ops || !se->ops->state_pending_estimate) {continue ;
@@ -1591,6 +1566,31 @@ void qemu_savevm_state_pending_exact(uint64_t *res_precopy_only, } } +void qemu_savevm_state_pending_exact (uint64_t *res_precopy_only, +uint64_t *res_compatible, +uint64_t *res_postcopy_only) +{ +SaveStateEntry *se; + + *res_precopy_only =0 ; + *res_compatible =0 ; + *res_postcopy_only =0 ; + + QTAILQ_FOREACH(se, &savevm_state.handlers, entry) { +if (!se->ops || !se->ops->state_pending_exact) { +continue ; + } +if (se->ops->is_active) { +if (!se->ops->is_active (se->opaque)) { +continue ; + } + } + se->ops->state_pending_exact (se->opaque, + res_precopy_only, res_compatible, + res_postcopy_only); + } +} +void qemu_savevm_state_cleanup (void ) {SaveStateEntry *se;
Signature · 1 line
2.39.1
[PULL 07/22] migration: Make find_dirty_block() return a single parameter
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
We used to return two bools, just return a single int with the following meaning:
old return / again / new return
false false PAGE_ALL_CLEAN false true PAGE_TRY_AGAIN true true PAGE_DIRTY_FOUND /* We don't care about again at all */
--- migration/ram.c | 37 ++++++++++++++++++++++--------------- 1 file changed, 22 insertions(+), 15 deletions(-)
migration/ram.c +22 -15
@@ -1546,17 +1546,23 @@ retry:return pages; } +#define PAGE_ALL_CLEAN 0 +#define PAGE_TRY_AGAIN 1 +#define PAGE_DIRTY_FOUND 2/** * find_dirty_block: find the next dirty page and update any state * associated with the search process. * -* Returns true if a page is found +* Returns: +* PAGE_ALL_CLEAN: no dirty page found, give up +* PAGE_TRY_AGAIN: no dirty page found, retry for next block +* PAGE_DIRTY_FOUND: dirty page found * * @rs: current RAM state * @pss: data about the state of the current dirty page scan * @again: set to false if the search has scanned the whole of RAM */ -static bool find_dirty_block (RAMState *rs,PageSearchStatus *pss,bool *again) +static int find_dirty_block (RAMState *rs,PageSearchStatus *pss) {/* Update pss->page for the next dirty bit in ramblock */ pss_find_next_dirty (pss);
@@ -1567,8 +1573,7 @@ static bool find_dirty_block(RAMState *rs, PageSearchStatus *pss, bool *again)* We've been once around the RAM and haven't found anything. * Give up. */ - *again = false; -return false; +return PAGE_ALL_CLEAN ; }if (!offset_in_ramblock (pss->block, ((ram_addr_t )pss->page) <<TARGET_PAGE_BITS )) {
@@ -1597,13 +1602,10 @@ static bool find_dirty_block(RAMState *rs, PageSearchStatus *pss, bool *again) } }/* Didn't find anything this time, but try again on the new block */ - *again = true; -return false; +return PAGE_TRY_AGAIN ; }else { -/* Can go around again, but... */ - *again = true; -/* We've found something so probably don't need to */ -return true; +/* We've found something */ +return PAGE_DIRTY_FOUND ; } }
@@ -2562,18 +2564,23 @@ static int ram_find_and_save_block(RAMState *rs)pss_init (pss, rs->last_seen_block, rs->last_page); -do { +while (true){if (!get_queued_page (rs, pss)) {/* priority queue empty, so just search for something dirty */ -bool again = true; -if (!find_dirty_block (rs, pss, &again)) { -if (!again) { +int res =find_dirty_block (rs, pss); +if (res !=PAGE_DIRTY_FOUND ) { +if (res ==PAGE_ALL_CLEAN ) {break ; + }else if (res ==PAGE_TRY_AGAIN ) { +continue ; } } } pages =ram_save_host_page (rs, pss); - }while (!pages); +if (pages) { +break ; + } + } rs->last_seen_block = pss->block; rs->last_page = pss->page;
Signature · 1 line
2.39.1
[PULL 16/22] migration: Add a semaphore to count PONGs
In reply to Xxx XxFrom: Peter Xu <[email protected]>
This is mostly useless, but useful for us to know whether the main channel is correctly established without changing the migration protocol.
--- migration/migration.h | 6 ++++++ migration/migration.c | 3 +++ 2 files changed, 9 insertions(+)
migration/migration.h +6 -0
@@ -276,6 +276,12 @@ struct MigrationState {*/ bool rp_thread_created;QemuSemaphore rp_sem; +/* +* We post to this when we got one PONG from dest. So far it's an +* easy way to know the main channel has successfully established +* on dest QEMU. +*/ +QemuSemaphore rp_pong_acks; } rp_state;double mbps;
migration/migration.c +3 -0
@@ -3025,6 +3025,7 @@ retry:case MIG_RP_MSG_PONG : tmp32 =ldl_be_p (buf);trace_source_return_path_thread_pong (tmp32); +qemu_sem_post (&ms->rp_state.rp_pong_acks);break ;case MIG_RP_MSG_REQ_PAGES :
@@ -4524,6 +4525,7 @@ static void migration_instance_finalize(Object *obj)qemu_sem_destroy (&ms->postcopy_pause_sem);qemu_sem_destroy (&ms->postcopy_pause_rp_sem);qemu_sem_destroy (&ms->rp_state.rp_sem); +qemu_sem_destroy (&ms->rp_state.rp_pong_acks);qemu_sem_destroy (&ms->postcopy_qemufile_src_sem);error_free (ms->error); }
@@ -4570,6 +4572,7 @@ static void migration_instance_init(Object *obj)qemu_sem_init (&ms->postcopy_pause_sem,0 );qemu_sem_init (&ms->postcopy_pause_rp_sem,0 );qemu_sem_init (&ms->rp_state.rp_sem,0 ); +qemu_sem_init (&ms->rp_state.rp_pong_acks,0 );qemu_sem_init (&ms->rate_limit_sem,0 );qemu_sem_init (&ms->wait_unplug_sem,0 );qemu_sem_init (&ms->postcopy_qemufile_src_sem,0 );
Signature · 1 line
2.39.1
[PULL 12/22] AVX512 support for xbzrle_encode_buffer
In reply to Xxx XxFrom: ling xu <[email protected]>
This commit is the same with [PATCH v6 1/2], and provides avx512 support for xbzrle_encode_buffer function to accelerate xbzrle encoding speed. Runtime check of avx512
support and benchmark for this feature are added. Compared with C
version of xbzrle_encode_buffer function, avx512 version can achieve
50%-70% performance improvement on benchmarking. In addition, if dirty
data is randomly located in 4K page, the avx512 version can achieve
almost 140% performance gain.
--- meson.build | 17 +++++ migration/xbzrle.h | 4 ++ migration/ram.c | 34 +++++++++- migration/xbzrle.c | 124 ++++++++++++++++++++++++++++++++++ meson_options.txt | 2 + scripts/meson-buildoptions.sh | 3 + 6 files changed, 181 insertions(+), 3 deletions(-)
meson.build +17 -0
@@ -2351,6 +2351,22 @@ config_host_data.set('CONFIG_AVX512F_OPT', get_option('avx512f') \ int main(int argc, char *argv[]) { return bar(argv[argc - 1]); } '''), error_message: 'AVX512F not available').allowed()) +config_host_data.set('CONFIG_AVX512BW_OPT', get_option('avx512bw') \ + .require(have_cpuid_h, error_message: 'cpuid.h not available, cannot enable AVX512BW') \ + .require(cc.links(''' + #pragma GCC push_options + #pragma GCC target("avx512bw") + #include <cpuid.h> + #include <immintrin.h> + static int bar(void *a) { + + __m512i *x = a; + __m512i res= _mm512_abs_epi8(*x); + return res[1]; + } + int main(int argc, char *argv[]) { return bar(argv[0]); } + '''), error_message: 'AVX512BW not available').allowed()) + have_pvrdma = get_option('pvrdma') \ .require(rdma.found(), error_message: 'PVRDMA requires OpenFabrics libraries') \ .require(cc.compiles(gnu_source_prefix + '''
@@ -3783,6 +3799,7 @@ summary_info += {'debug stack usage': get_option('debug_stack_usage')} summary_info += {'mutex debugging': get_option('debug_mutex')} summary_info += {'memory allocator': get_option('malloc')} summary_info += {'avx2 optimization': config_host_data.get('CONFIG_AVX2_OPT')} +summary_info += {'avx512bw optimization': config_host_data.get('CONFIG_AVX512BW_OPT')} summary_info += {'avx512f optimization': config_host_data.get('CONFIG_AVX512F_OPT')} summary_info += {'gprof enabled': get_option('gprof')} summary_info += {'gcov': get_option('b_coverage')}
migration/xbzrle.h +4 -0
@@ -18,4 +18,8 @@ int xbzrle_encode_buffer(uint8_t *old_buf, uint8_t *new_buf, int slen, uint8_t *dst, int dlen);int xbzrle_decode_buffer (uint8_t *src,int slen,uint8_t *dst,int dlen); +#if defined(CONFIG_AVX512BW_OPT ) +int xbzrle_encode_buffer_avx512 (uint8_t *old_buf,uint8_t *new_buf,int slen, +uint8_t *dst,int dlen); +#endif #endif
migration/ram.c +31 -3
@@ -83,6 +83,34 @@/* 0x80 is reserved in migration.h start with 0x100 next */ #define RAM_SAVE_FLAG_COMPRESS_PAGE 0x100 +int (*xbzrle_encode_buffer_func)(uint8_t *,uint8_t *,int , +uint8_t *,int ) = xbzrle_encode_buffer; +#if defined(CONFIG_AVX512BW_OPT ) +#include "qemu/cpuid.h" +static void __attribute__((constructor))init_cpu_flag (void ) +{ +unsigned max =__get_cpuid_max (0 ,NULL ); +int a, b, c, d; +if (max >=1 ) { +__cpuid (1 , a, b, c, d); +/* We must check that AVX is not just available, but usable. */ +if ((c & bit_OSXSAVE) && (c & bit_AVX) && max >=7 ) { +int bv; + __asm("xgetbv" :"=a" (bv),"=d" (d) :"c" (0 )); +__cpuid_count (7 ,0 , a, b, c, d); +/* 0xe6: +* XCR0[7:5] = 111b (OPMASK state, upper 256-bit of ZMM0-ZMM15 +* and ZMM16-ZMM31 state are enabled by OS) +* XCR0[2:1] = 11b (XMM state and YMM state are enabled by OS) +*/ +if ((bv &0xe6 ) ==0xe6 && (b & bit_AVX512BW)) { + xbzrle_encode_buffer_func = xbzrle_encode_buffer_avx512; + } + } + } +} +#endif +XBZRLECacheStats xbzrle_counters;/* used by the search for pages to send */
@@ -806,9 +834,9 @@ static int save_xbzrle_page(RAMState *rs, PageSearchStatus *pss,memcpy (XBZRLE .current_buf, *current_data,TARGET_PAGE_SIZE );/* XBZRLE encoding (if there is no overflow) */ - encoded_len =xbzrle_encode_buffer (prev_cached_page,XBZRLE .current_buf, -TARGET_PAGE_SIZE ,XBZRLE .encoded_buf, -TARGET_PAGE_SIZE ); + encoded_len =xbzrle_encode_buffer_func (prev_cached_page,XBZRLE .current_buf, +TARGET_PAGE_SIZE ,XBZRLE .encoded_buf, +TARGET_PAGE_SIZE );/* * Update the cache contents, so that it corresponds to the data
migration/xbzrle.c +124 -0
127 lines not on this page · raw message
meson_options.txt +2 -0
@@ -104,6 +104,8 @@ option('avx2', type: 'feature', value: 'auto', description: 'AVX2 optimizations') option('avx512f', type: 'feature', value: 'disabled', description: 'AVX512F optimizations') +option('avx512bw', type: 'feature', value: 'auto', + description: 'AVX512BW optimizations') option('keyring', type: 'feature', value: 'auto', description: 'Linux keyring support')
scripts/meson-buildoptions.sh +3 -0
@@ -70,6 +70,7 @@ meson_options_help() { printf "%s\n" ' attr attr/xattr support' printf "%s\n" ' auth-pam PAM access control' printf "%s\n" ' avx2 AVX2 optimizations' + printf "%s\n" ' avx512bw AVX512BW optimizations' printf "%s\n" ' avx512f AVX512F optimizations' printf "%s\n" ' blkio libblkio block device driver' printf "%s\n" ' bochs bochs image format support'
@@ -198,6 +199,8 @@ _meson_option_parse() { --disable-auth-pam) printf "%s" -Dauth_pam=disabled ;; --enable-avx2) printf "%s" -Davx2=enabled ;; --disable-avx2) printf "%s" -Davx2=disabled ;; + --enable-avx512bw) printf "%s" -Davx512bw=enabled ;; + --disable-avx512bw) printf "%s" -Davx512bw=disabled ;; --enable-avx512f) printf "%s" -Davx512f=enabled ;; --disable-avx512f) printf "%s" -Davx512f=disabled ;; --enable-gcov) printf "%s" -Db_coverage=true ;;
Signature · 1 line
2.39.1
[PULL 17/22] migration: Postpone postcopy preempt channel to be after main
In reply to Xxx XxFrom: Peter Xu <[email protected]>
Postcopy with preempt-mode enabled needs two channels to communicate. The order of channel establishment is not guaranteed. It can happen that the dest QEMU got the preempt channel connection request before the main channel is established, then the migration may make no progress even during precopy due to the wrong order.
To fix it, create the preempt channel only if we know the main channel is established.
For a general postcopy migration, we delay it until postcopy_start(), that's where we already went through some part of precopy on the main channel. To make sure dest QEMU has already established the channel, we wait until we got the first PONG received. That's something we do at the start of precopy when postcopy enabled so it's guaranteed to happen sooner or later.
For a postcopy recovery, we delay it to qemu_savevm_state_resume_prepare() where we'll have round trips of data on bitmap synchronizations, which means the main channel must have been established.
--- migration/migration.h | 6 ++++ migration/postcopy-ram.h | 2 +- migration/migration.c | 72 ++++++++++++++++++++++++++++++---------- migration/postcopy-ram.c | 17 ++++++++-- migration/savevm.c | 6 +++- 5 files changed, 82 insertions(+), 21 deletions(-)
migration/migration.h +6 -0
@@ -116,6 +116,12 @@ struct MigrationIncomingState {unsigned int postcopy_channels;/* QEMUFile for postcopy only; it'll be handled by a separate thread */ QEMUFile *postcopy_qemufile_dst; +/* +* When postcopy_qemufile_dst is properly setup, this sem is posted. +* One can wait on this semaphore to wait until the preempt channel is +* properly setup. +*/ +QemuSemaphore postcopy_qemufile_dst_done;/* Postcopy priority thread is used to receive postcopy requested pages */ QemuThread postcopy_prio_thread;bool postcopy_prio_thread_created;
migration/postcopy-ram.h +1 -1
@@ -192,6 +192,6 @@ enum PostcopyChannels {void postcopy_preempt_new_channel (MigrationIncomingState *mis,QEMUFile *file);void postcopy_preempt_setup (MigrationState *s); -int postcopy_preempt_wait_channel (MigrationState *s); +int postcopy_preempt_establish_channel (MigrationState *s);#endif
migration/migration.c +55 -17
120 lines not on this page · raw message
migration/postcopy-ram.c +15 -2
@@ -1197,6 +1197,11 @@ int postcopy_ram_incoming_setup(MigrationIncomingState *mis) }if (migrate_postcopy_preempt ()) { +/* +* The preempt channel is established in asynchronous way. Wait +* for its completion. +*/ +qemu_sem_wait (&mis->postcopy_qemufile_dst_done);/* * This thread needs to be created after the temp pages because * it'll fetch RAM_CHANNEL_POSTCOPY PostcopyTmpPage immediately.
@@ -1544,6 +1549,7 @@ void postcopy_preempt_new_channel(MigrationIncomingState *mis, QEMUFile *file)*/ qemu_file_set_blocking (file, true); mis->postcopy_qemufile_dst = file; +qemu_sem_post (&mis->postcopy_qemufile_dst_done);trace_postcopy_preempt_new_channel (); }
@@ -1612,14 +1618,21 @@ out:postcopy_preempt_send_channel_done (s, ioc, local_err); } -/* Returns 0 if channel established, -1 for error. */ -int postcopy_preempt_wait_channel (MigrationState *s) +/* +* This function will kick off an async task to establish the preempt +* channel, and wait until the connection setup completed. Returns 0 if +* channel established, -1 for error. +*/ +int postcopy_preempt_establish_channel (MigrationState *s) {/* If preempt not enabled, no need to wait */ if (!migrate_postcopy_preempt ()) {return 0 ; } +/* Kick off async task to establish preempt channel */ +postcopy_preempt_setup (s); +/* * We need the postcopy preempt channel to be established before * starting doing anything.
migration/savevm.c +5 -1
@@ -2200,7 +2200,11 @@ static int loadvm_postcopy_handle_resume(MigrationIncomingState *mis)qemu_sem_post (&mis->postcopy_pause_sem_fault);if (migrate_postcopy_preempt ()) { -/* The channel should already be setup again; make sure of it */ +/* +* The preempt channel will be created in async manner, now let's +* wait for it and make sure it's created. +*/ +qemu_sem_wait (&mis->postcopy_qemufile_dst_done);assert (mis->postcopy_qemufile_dst);/* Kick the fast ram load thread too */ qemu_sem_post (&mis->postcopy_pause_sem_fast_load);
Signature · 1 line
2.39.1
[PULL 13/22] Update bench-code for addressing CI problem
In reply to Xxx XxFrom: ling xu <[email protected]>
Unit test code is in test-xbzrle.c, and benchmark code is in xbzrle-bench.c for performance benchmarking. we have modified xbzrle-bench.c to address CI problem.
--- tests/bench/xbzrle-bench.c | 469 +++++++++++++++++++++++++++++++++++++ tests/unit/test-xbzrle.c | 39 ++- tests/bench/meson.build | 6 + 3 files changed, 509 insertions(+), 5 deletions(-) create mode 100644 tests/bench/xbzrle-bench.c
tests/bench/xbzrle-bench.c new file +469 -0
@@ -0,0 +1,469 @@ +/* +* Xor Based Zero Run Length Encoding unit tests. +* +* Copyright 2013 Red Hat, Inc. and/or its affiliates +* +* Authors: +* Orit Wasserman <[email protected]> +* +* This work is licensed under the terms of the GNU GPL, version 2 or later. +* See the COPYING file in the top-level directory. +* +*/ +#include "qemu/osdep.h" +#include "qemu/cutils.h" +#include "../migration/xbzrle.h" + +#if defined(CONFIG_AVX512BW_OPT ) +#define XBZRLE_PAGE_SIZE 4096 +static bool is_cpu_support_avx512bw; +#include "qemu/cpuid.h" +static void __attribute__((constructor))init_cpu_flag (void ) +{ +unsigned max =__get_cpuid_max (0 ,NULL ); +int a, b, c, d; + is_cpu_support_avx512bw = false; +if (max >=1 ) { +__cpuid (1 , a, b, c, d); +/* We must check that AVX is not just available, but usable. */ +if ((c & bit_OSXSAVE) && (c & bit_AVX) && max >=7 ) { +int bv; + __asm("xgetbv" :"=a" (bv),"=d" (d) :"c" (0 )); +__cpuid_count (7 ,0 , a, b, c, d); +/* 0xe6: +* XCR0[7:5] = 111b (OPMASK state, upper 256-bit of ZMM0-ZMM15 +* and ZMM16-ZMM31 state are enabled by OS) +* XCR0[2:1] = 11b (XMM state and YMM state are enabled by OS) +*/ +if ((bv &0xe6 ) ==0xe6 && (b & bit_AVX512BW)) { + is_cpu_support_avx512bw = true; + } + } + } +return ; +} + +struct ResTime { +float t_raw; +float t_512; +}; + + +/* Function prototypes +int xbzrle_encode_buffer_avx512(uint8_t *old_buf, uint8_t *new_buf, int slen, +uint8_t *dst, int dlen); +*/ +static void encode_decode_zero (struct ResTime *res) +{ +uint8_t *buffer =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *buffer512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +int i =0 ; +int dlen =0 , dlen512 =0 ; +int diff_len =g_test_rand_int_range (0 ,XBZRLE_PAGE_SIZE -1006 ); + +for (i = diff_len; i >0 ; i--) { + buffer[1000 + i] = i; + buffer512[1000 + i] = i; + } + + buffer[1000 + diff_len +3 ] =103 ; + buffer[1000 + diff_len +5 ] =105 ; + + buffer512[1000 + diff_len +3 ] =103 ; + buffer512[1000 + diff_len +5 ] =105 ; + +/* encode zero page */ +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + dlen =xbzrle_encode_buffer (buffer, buffer,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); +g_assert (dlen ==0 ); + + t_start512 =clock (); + dlen512 =xbzrle_encode_buffer_avx512 (buffer512, buffer512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); +g_assert (dlen512 ==0 ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (buffer); +g_free (compressed); +g_free (buffer512); +g_free (compressed512); + +} + +static void test_encode_decode_zero_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_zero (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("Zero test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} + +static void encode_decode_unchanged (struct ResTime *res) +{ +uint8_t *compressed =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +int i =0 ; +int dlen =0 , dlen512 =0 ; +int diff_len =g_test_rand_int_range (0 ,XBZRLE_PAGE_SIZE -1006 ); + +for (i = diff_len; i >0 ; i--) { + test[1000 + i] = i +4 ; + test512[1000 + i] = i +4 ; + } + + test[1000 + diff_len +3 ] =107 ; + test[1000 + diff_len +5 ] =109 ; + + test512[1000 + diff_len +3 ] =107 ; + test512[1000 + diff_len +5 ] =109 ; + +/* test unchanged buffer */ +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + dlen =xbzrle_encode_buffer (test, test,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); +g_assert (dlen ==0 ); + + t_start512 =clock (); + dlen512 =xbzrle_encode_buffer_avx512 (test512, test512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); +g_assert (dlen512 ==0 ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (test); +g_free (compressed); +g_free (test512); +g_free (compressed512); + +} + +static void test_encode_decode_unchanged_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_unchanged (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("Unchanged test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} + +static void encode_decode_1_byte (struct ResTime *res) +{ +uint8_t *buffer =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed =g_malloc (XBZRLE_PAGE_SIZE ); +uint8_t *buffer512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc (XBZRLE_PAGE_SIZE ); +int dlen =0 , rc =0 , dlen512 =0 , rc512 =0 ; +uint8_t buf[2 ]; +uint8_t buf512[2 ]; + + test[XBZRLE_PAGE_SIZE -1 ] =1 ; + test512[XBZRLE_PAGE_SIZE -1 ] =1 ; + +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + dlen =xbzrle_encode_buffer (buffer, test,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); +g_assert (dlen == (uleb128_encode_small (&buf[0 ],4095 ) +2 )); + + rc =xbzrle_decode_buffer (compressed, dlen, buffer,XBZRLE_PAGE_SIZE ); +g_assert (rc ==XBZRLE_PAGE_SIZE ); +g_assert (memcmp (test, buffer,XBZRLE_PAGE_SIZE ) ==0 ); + + t_start512 =clock (); + dlen512 =xbzrle_encode_buffer_avx512 (buffer512, test512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); +g_assert (dlen512 == (uleb128_encode_small (&buf512[0 ],4095 ) +2 )); + + rc512 =xbzrle_decode_buffer (compressed512, dlen512, buffer512, +XBZRLE_PAGE_SIZE ); +g_assert (rc512 ==XBZRLE_PAGE_SIZE ); +g_assert (memcmp (test512, buffer512,XBZRLE_PAGE_SIZE ) ==0 ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (buffer); +g_free (compressed); +g_free (test); +g_free (buffer512); +g_free (compressed512); +g_free (test512); + +} + +static void test_encode_decode_1_byte_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_1_byte (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("1 byte test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} + +static void encode_decode_overflow (struct ResTime *res) +{ +uint8_t *compressed =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *buffer =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *test512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *buffer512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +int i =0 , rc =0 , rc512 =0 ; + +for (i =0 ; i <XBZRLE_PAGE_SIZE /2 -1 ; i++) { + test[i *2 ] =1 ; + test512[i *2 ] =1 ; + } + +/* encode overflow */ +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + rc =xbzrle_encode_buffer (buffer, test,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); +g_assert (rc ==-1 ); + + t_start512 =clock (); + rc512 =xbzrle_encode_buffer_avx512 (buffer512, test512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); +g_assert (rc512 ==-1 ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (buffer); +g_free (compressed); +g_free (test); +g_free (buffer512); +g_free (compressed512); +g_free (test512); + +} + +static void test_encode_decode_overflow_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_overflow (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("Overflow test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} + +static void encode_decode_range_avx512 (struct ResTime *res) +{ +uint8_t *buffer =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed =g_malloc (XBZRLE_PAGE_SIZE ); +uint8_t *test =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *buffer512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc (XBZRLE_PAGE_SIZE ); +uint8_t *test512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +int i =0 , rc =0 , rc512 =0 ; +int dlen =0 , dlen512 =0 ; + +int diff_len =g_test_rand_int_range (0 ,XBZRLE_PAGE_SIZE -1006 ); + +for (i = diff_len; i >0 ; i--) { + buffer[1000 + i] = i; + test[1000 + i] = i +4 ; + buffer512[1000 + i] = i; + test512[1000 + i] = i +4 ; + } + + buffer[1000 + diff_len +3 ] =103 ; + test[1000 + diff_len +3 ] =107 ; + + buffer[1000 + diff_len +5 ] =105 ; + test[1000 + diff_len +5 ] =109 ; + + buffer512[1000 + diff_len +3 ] =103 ; + test512[1000 + diff_len +3 ] =107 ; + + buffer512[1000 + diff_len +5 ] =105 ; + test512[1000 + diff_len +5 ] =109 ; + +/* test encode/decode */ +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + dlen =xbzrle_encode_buffer (test, buffer,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); + rc =xbzrle_decode_buffer (compressed, dlen, test,XBZRLE_PAGE_SIZE ); +g_assert (rc <XBZRLE_PAGE_SIZE ); +g_assert (memcmp (test, buffer,XBZRLE_PAGE_SIZE ) ==0 ); + + t_start512 =clock (); + dlen512 =xbzrle_encode_buffer_avx512 (test512, buffer512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); + rc512 =xbzrle_decode_buffer (compressed512, dlen512, test512,XBZRLE_PAGE_SIZE ); +g_assert (rc512 <XBZRLE_PAGE_SIZE ); +g_assert (memcmp (test512, buffer512,XBZRLE_PAGE_SIZE ) ==0 ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (buffer); +g_free (compressed); +g_free (test); +g_free (buffer512); +g_free (compressed512); +g_free (test512); + +} + +static void test_encode_decode_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_range_avx512 (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("Encode decode test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} + +static void encode_decode_random (struct ResTime *res) +{ +uint8_t *buffer =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed =g_malloc (XBZRLE_PAGE_SIZE ); +uint8_t *test =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *buffer512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +uint8_t *compressed512 =g_malloc (XBZRLE_PAGE_SIZE ); +uint8_t *test512 =g_malloc0 (XBZRLE_PAGE_SIZE ); +int i =0 , rc =0 , rc512 =0 ; +int dlen =0 , dlen512 =0 ; + +int diff_len =g_test_rand_int_range (0 ,XBZRLE_PAGE_SIZE -1 ); +/* store the index of diff */ +int dirty_index[diff_len]; +for (int j =0 ; j < diff_len; j++) { + dirty_index[j] =g_test_rand_int_range (0 ,XBZRLE_PAGE_SIZE -1 ); + } +for (i = diff_len -1 ; i >=0 ; i--) { + buffer[dirty_index[i]] = i; + test[dirty_index[i]] = i +4 ; + buffer512[dirty_index[i]] = i; + test512[dirty_index[i]] = i +4 ; + } + +time_t t_start, t_end, t_start512, t_end512; + t_start =clock (); + dlen =xbzrle_encode_buffer (test, buffer,XBZRLE_PAGE_SIZE , compressed, +XBZRLE_PAGE_SIZE ); + t_end =clock (); +float time_val =difftime (t_end, t_start); + rc =xbzrle_decode_buffer (compressed, dlen, test,XBZRLE_PAGE_SIZE ); +g_assert (rc <XBZRLE_PAGE_SIZE ); + + t_start512 =clock (); + dlen512 =xbzrle_encode_buffer_avx512 (test512, buffer512,XBZRLE_PAGE_SIZE , + compressed512,XBZRLE_PAGE_SIZE ); + t_end512 =clock (); +float time_val512 =difftime (t_end512, t_start512); + rc512 =xbzrle_decode_buffer (compressed512, dlen512, test512,XBZRLE_PAGE_SIZE ); +g_assert (rc512 <XBZRLE_PAGE_SIZE ); + + res->t_raw = time_val; + res->t_512 = time_val512; + +g_free (buffer); +g_free (compressed); +g_free (test); +g_free (buffer512); +g_free (compressed512); +g_free (test512); + +} + +static void test_encode_decode_random_avx512 (void ) +{ +int i; +float time_raw =0.0 , time_512 =0.0 ; +struct ResTime res; +for (i =0 ; i <10000 ; i++) { +encode_decode_random (&res); + time_raw += res.t_raw; + time_512 += res.t_512; + } +printf ("Random test:\n" ); +printf ("Raw xbzrle_encode time is %f ms\n" , time_raw); +printf ("512 xbzrle_encode time is %f ms\n" , time_512); +} +#endif + +int main (int argc,char **argv) +{ +g_test_init (&argc, &argv,NULL ); +g_test_rand_int (); +#if defined(CONFIG_AVX512BW_OPT ) +if (likely (is_cpu_support_avx512bw)) { +g_test_add_func ("/xbzrle/encode_decode_zero" , test_encode_decode_zero_avx512); +g_test_add_func ("/xbzrle/encode_decode_unchanged" , + test_encode_decode_unchanged_avx512); +g_test_add_func ("/xbzrle/encode_decode_1_byte" , test_encode_decode_1_byte_avx512); +g_test_add_func ("/xbzrle/encode_decode_overflow" , + test_encode_decode_overflow_avx512); +g_test_add_func ("/xbzrle/encode_decode" , test_encode_decode_avx512); +g_test_add_func ("/xbzrle/encode_decode_random" , test_encode_decode_random_avx512); + } +#endif +return g_test_run (); +}
tests/unit/test-xbzrle.c +34 -5
@@ -16,6 +16,35 @@#define XBZRLE_PAGE_SIZE 4096 +int (*xbzrle_encode_buffer_func)(uint8_t *,uint8_t *,int , +uint8_t *,int ) = xbzrle_encode_buffer; +#if defined(CONFIG_AVX512BW_OPT ) +#include "qemu/cpuid.h" +static void __attribute__((constructor))init_cpu_flag (void ) +{ +unsigned max =__get_cpuid_max (0 ,NULL ); +int a, b, c, d; +if (max >=1 ) { +__cpuid (1 , a, b, c, d); +/* We must check that AVX is not just available, but usable. */ +if ((c & bit_OSXSAVE) && (c & bit_AVX) && max >=7 ) { +int bv; + __asm("xgetbv" :"=a" (bv),"=d" (d) :"c" (0 )); +__cpuid_count (7 ,0 , a, b, c, d); +/* 0xe6: +* XCR0[7:5] = 111b (OPMASK state, upper 256-bit of ZMM0-ZMM15 +* and ZMM16-ZMM31 state are enabled by OS) +* XCR0[2:1] = 11b (XMM state and YMM state are enabled by OS) +*/ +if ((bv &0xe6 ) ==0xe6 && (b & bit_AVX512BW)) { + xbzrle_encode_buffer_func = xbzrle_encode_buffer_avx512; + } + } + } +return ; +} +#endif +static void test_uleb (void ) {uint32_t i, val;
@@ -54,7 +83,7 @@ static void test_encode_decode_zero(void) buffer[1000 + diff_len +5 ] =105 ;/* encode zero page */ - dlen =xbzrle_encode_buffer (buffer, buffer,XBZRLE_PAGE_SIZE , compressed, + dlen =xbzrle_encode_buffer_func (buffer, buffer,XBZRLE_PAGE_SIZE , compressed,XBZRLE_PAGE_SIZE );g_assert (dlen ==0 );
@@ -78,7 +107,7 @@ static void test_encode_decode_unchanged(void) test[1000 + diff_len +5 ] =109 ;/* test unchanged buffer */ - dlen =xbzrle_encode_buffer (test, test,XBZRLE_PAGE_SIZE , compressed, + dlen =xbzrle_encode_buffer_func (test, test,XBZRLE_PAGE_SIZE , compressed,XBZRLE_PAGE_SIZE );g_assert (dlen ==0 );
@@ -96,7 +125,7 @@ static void test_encode_decode_1_byte(void) test[XBZRLE_PAGE_SIZE -1 ] =1 ; - dlen =xbzrle_encode_buffer (buffer, test,XBZRLE_PAGE_SIZE , compressed, + dlen =xbzrle_encode_buffer_func (buffer, test,XBZRLE_PAGE_SIZE , compressed,XBZRLE_PAGE_SIZE );g_assert (dlen == (uleb128_encode_small (&buf[0 ],4095 ) +2 ));
@@ -121,7 +150,7 @@ static void test_encode_decode_overflow(void) }/* encode overflow */ - rc =xbzrle_encode_buffer (buffer, test,XBZRLE_PAGE_SIZE , compressed, + rc =xbzrle_encode_buffer_func (buffer, test,XBZRLE_PAGE_SIZE , compressed,XBZRLE_PAGE_SIZE );g_assert (rc ==-1 );
@@ -152,7 +181,7 @@ static void encode_decode_range(void) test[1000 + diff_len +5 ] =109 ;/* test encode/decode */ - dlen =xbzrle_encode_buffer (test, buffer,XBZRLE_PAGE_SIZE , compressed, + dlen =xbzrle_encode_buffer_func (test, buffer,XBZRLE_PAGE_SIZE , compressed,XBZRLE_PAGE_SIZE ); rc =xbzrle_decode_buffer (compressed, dlen, test,XBZRLE_PAGE_SIZE );
tests/bench/meson.build +6 -0
@@ -3,6 +3,12 @@ qht_bench = executable('qht-bench', sources: 'qht-bench.c', dependencies: [qemuutil]) +if have_system +xbzrle_bench = executable('xbzrle-bench', + sources: 'xbzrle-bench.c', + dependencies: [qemuutil,migration]) +endif + executable('atomic_add-bench', sources: files('atomic_add-bench.c'), dependencies: [qemuutil],
Signature · 1 line
2.39.1
[PULL 14/22] migration: Rework multi-channel checks on URI
In reply to Xxx XxFrom: Peter Xu <[email protected]>
The whole idea of multi-channel checks was not properly done, IMHO.
Currently we check multi-channel in a lot of places, but actually that's not needed because we only need to check it right after we get the URI and that should be it.
If the URI check succeeded, we should never need to check it again because we must have it. If it check fails, we should fail immediately on either the qmp_migrate or qmp_migrate_incoming, instead of failingg it later after the connection established.
Neither should we fail any set capabiliities like what we used to do here:
5ad15e8614 ("migration: allow enabling mutilfd for specific protocol only", 2021-10-19)
Because logically the URI will only be set later after the capability is set, so it doesn't make a lot of sense to check the URI type when setting the capability, because we're checking the cap with an old URI passed in, and that may not even be the URI we're going to use later.
This patch mostly reverted all such checks for before, dropping the variable migrate_allow_multi_channels and helpers. Instead, add a common helper to check URI for multi-channels for either qmp_migrate and qmp_migrate_incoming and that should do all the proper checks. The failure will only trigger with the "migrate" or "migrate_incoming" command, or when user specified "-incoming xxx" where "xxx" is not "defer".
--- migration/migration.h | 3 --- migration/migration.c | 49 +++++++++++++++++++++------------------- migration/multifd.c | 12 ++-------- migration/postcopy-ram.c | 6 ----- 4 files changed, 28 insertions(+), 42 deletions(-)
migration/migration.h +0 -3
@@ -474,7 +474,4 @@ void migration_cancel(const Error *error);void populate_vfio_info (MigrationInfo *info);void postcopy_temp_page_reset (PostcopyTmpPage *tmp_page); -bool migrate_multi_channels_is_allowed (void ); -void migrate_protocol_allow_multi_channels (bool allow); -#endif
migration/migration.c +26 -23
97 lines not on this page · raw message
migration/multifd.c +2 -10
@@ -516,7 +516,7 @@ void multifd_save_cleanup(void) {int i; -if (!migrate_use_multifd () || !migrate_multi_channels_is_allowed ()) { +if (!migrate_use_multifd ()) {return ; }multifd_send_terminate_threads (NULL );
@@ -913,10 +913,6 @@ int multifd_save_setup(Error **errp)if (!migrate_use_multifd ()) {return 0 ; } -if (!migrate_multi_channels_is_allowed ()) { -error_setg (errp,"multifd is not supported by current protocol" ); -return -1 ; - } thread_count =migrate_multifd_channels (); multifd_send_state =g_malloc0 (sizeof (*multifd_send_state));
@@ -1021,7 +1017,7 @@ int multifd_load_cleanup(Error **errp) {int i; -if (!migrate_use_multifd () || !migrate_multi_channels_is_allowed ()) { +if (!migrate_use_multifd ()) {return 0 ; }multifd_recv_terminate_threads (NULL );
@@ -1172,10 +1168,6 @@ int multifd_load_setup(Error **errp)return 0 ; } -if (!migrate_multi_channels_is_allowed ()) { -error_setg (errp,"multifd is not supported by current protocol" ); -return -1 ; - } thread_count =migrate_multifd_channels (); multifd_recv_state =g_malloc0 (sizeof (*multifd_recv_state)); multifd_recv_state->params =g_new0 (MultiFDRecvParams, thread_count);
migration/postcopy-ram.c +0 -6
@@ -1635,12 +1635,6 @@ int postcopy_preempt_setup(MigrationState *s, Error **errp)return 0 ; } -if (!migrate_multi_channels_is_allowed ()) { -error_setg (errp,"Postcopy preempt is not supported as current " -"migration stream does not support multi-channels." ); -return -1 ; - } -/* Kick an async task to connect */ socket_send_channel_create (postcopy_preempt_send_channel_new, s);
Signature · 1 line
2.39.1
[PULL 21/22] migration/multifd: Move load_cleanup inside incoming_state_destroy
In reply to Xxx XxFrom: Leonardo Bras <[email protected]>
Currently running migration_incoming_state_destroy() without first running multifd_load_cleanup() will cause a yank error:
qemu-system-x86_64: ../util/yank.c:107: yank_unregister_instance:
Assertion `QLIST_EMPTY(&entry->yankfns)' failed.
(core dumped)
The above error happens in the target host, when multifd is being used for precopy, and then postcopy is triggered and the migration finishes. This will crash the VM in the target host.
To avoid that, move multifd_load_cleanup() inside migration_incoming_state_destroy(), so that the load cleanup becomes part of the incoming state destroying process.
Running multifd_load_cleanup() twice can become an issue, though, but the only scenario it could be ran twice is on process_incoming_migration_bh(). So removing this extra call is necessary.
On the other hand, this multifd_load_cleanup() call happens way before the migration_incoming_state_destroy() and having this happening before dirty_bitmap_mig_before_vm_start() and vm_start() may be a need.
So introduce a new function multifd_load_shutdown() that will mainly stop all multifd threads and close their QIOChannels. Then use this function instead of multifd_load_cleanup() to make sure nothing else is received before dirty_bitmap_mig_before_vm_start().
--- migration/multifd.h | 1 + migration/migration.c | 4 +++- migration/multifd.c | 7 +++++++ 3 files changed, 11 insertions(+), 1 deletion(-)
migration/multifd.h +1 -0
@@ -17,6 +17,7 @@ int multifd_save_setup(Error **errp);void multifd_save_cleanup (void );int multifd_load_setup (Error **errp);void multifd_load_cleanup (void ); +void multifd_load_shutdown (void );bool multifd_recv_all_channels_created (void );void multifd_recv_new_channel (QIOChannel *ioc,Error **errp);void multifd_recv_sync_main (void );
migration/migration.c +3 -1
@@ -315,6 +315,8 @@ void migration_incoming_state_destroy(void) {struct MigrationIncomingState *mis =migration_incoming_get_current (); +multifd_load_cleanup (); +if (mis->to_src_file) {/* Tell source that we are done */ migrate_send_rp_shut (mis,qemu_file_get_error (mis->from_src_file) !=0 );
@@ -559,7 +561,7 @@ static void process_incoming_migration_bh(void *opaque)*/ qemu_announce_self (&mis->announce_timer,migrate_announce_params ()); -multifd_load_cleanup (); +multifd_load_shutdown ();dirty_bitmap_mig_before_vm_start ();
migration/multifd.c +7 -0
@@ -1013,6 +1013,13 @@ static void multifd_recv_terminate_threads(Error *err) } } +void multifd_load_shutdown (void ) +{ +if (migrate_use_multifd ()) { +multifd_recv_terminate_threads (NULL ); + } +} +void multifd_load_cleanup (void ) {int i;
Signature · 1 line
2.39.1
[PULL 19/22] migration/multifd: Remove unnecessary assignment on multifd_load_cleanup()
In reply to Xxx XxFrom: Leonardo Bras <[email protected]>
Before assigning "p->quit = true" for every multifd channel, multifd_load_cleanup() will call multifd_recv_terminate_threads() which already does the same assignment, while protected by a mutex.
So there is no point doing the same assignment again.
--- migration/multifd.c | 1 - 1 file changed, 1 deletion(-)
migration/multifd.c +0 -1
@@ -1025,7 +1025,6 @@ void multifd_load_cleanup(void)MultiFDRecvParams *p = &multifd_recv_state->params[i];if (p->running) { - p->quit = true;/* * multifd_recv_thread may hung at MULTIFD_FLAG_SYNC handle code, * however try to wakeup it without harm in cleanup phase.
Signature · 1 line
2.39.1
[PULL 22/22] ram: Document migration ram flags
In reply to Xxx XxFrom: Juan Quintela <[email protected]>
0x80 is RAM_SAVE_FLAG_HOOK, it is in qemu-file now. Bigger usable flag is 0x200, noticing that. We can reuse RAM_SAVe_FLAG_FULL.
--- migration/ram.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
migration/ram.c +10 -6
@@ -67,21 +67,25 @@/***********************************************************/ /* ram save/restore */ -/* RAM_SAVE_FLAG_ZERO used to be named RAM_SAVE_FLAG_COMPRESS, it -* worked for pages that where filled with the same char. We switched +/* +* RAM_SAVE_FLAG_ZERO used to be named RAM_SAVE_FLAG_COMPRESS, it +* worked for pages that were filled with the same char. We switched * it to only search for the zero value. And to avoid confusion with -* RAM_SSAVE_FLAG_COMPRESS_PAGE just rename it. +* RAM_SAVE_FLAG_COMPRESS_PAGE just rename it. */ - -#define RAM_SAVE_FLAG_FULL 0x01/* Obsolete, not used anymore */ +/* +* RAM_SAVE_FLAG_FULL was obsoleted in 2009, it can be reused now +*/ +#define RAM_SAVE_FLAG_FULL 0x01#define RAM_SAVE_FLAG_ZERO 0x02#define RAM_SAVE_FLAG_MEM_SIZE 0x04#define RAM_SAVE_FLAG_PAGE 0x08#define RAM_SAVE_FLAG_EOS 0x10#define RAM_SAVE_FLAG_CONTINUE 0x20#define RAM_SAVE_FLAG_XBZRLE 0x40 -/* 0x80 is reserved in migration.h start with 0x100 next */ +/* 0x80 is reserved in qemu-file.h for RAM_SAVE_FLAG_HOOK */ #define RAM_SAVE_FLAG_COMPRESS_PAGE 0x100 +/* We can't use any flag that is bigger than 0x200 */ int (*xbzrle_encode_buffer_func)(uint8_t *,uint8_t *,int ,uint8_t *,int ) = xbzrle_encode_buffer;
Signature · 1 line
2.39.1
[PULL 18/22] migration/multifd: Change multifd_load_cleanup() signature and usage
In reply to Xxx XxFrom: Leonardo Bras <[email protected]>
Since it's introduction in commit f986c3d256 ("migration: Create multifd migration threads"), multifd_load_cleanup() never returned any value different than 0, neither set up any error on errp.
Even though, on process_incoming_migration_bh() an if clause uses it's return value to decide on setting autostart = false, which will never happen.
In order to simplify the codebase, change multifd_load_cleanup() signature to 'void multifd_load_cleanup(void)', and for every usage remove error handling or decision made based on return value != 0.
--- migration/multifd.h | 2 +- migration/migration.c | 14 ++++---------- migration/multifd.c | 6 ++---- 3 files changed, 7 insertions(+), 15 deletions(-)
migration/multifd.h +1 -1
@@ -16,7 +16,7 @@int multifd_save_setup (Error **errp);void multifd_save_cleanup (void );int multifd_load_setup (Error **errp); -int multifd_load_cleanup (Error **errp); +void multifd_load_cleanup (void );bool multifd_recv_all_channels_created (void );void multifd_recv_new_channel (QIOChannel *ioc,Error **errp);void multifd_recv_sync_main (void );
migration/migration.c +4 -10
@@ -559,13 +559,7 @@ static void process_incoming_migration_bh(void *opaque)*/ qemu_announce_self (&mis->announce_timer,migrate_announce_params ()); -if (multifd_load_cleanup (&local_err) !=0 ) { -error_report_err (local_err); - autostart = false; - } -/* If global state section was not received or we are in running -state, we need to obey autostart. Any other state is set with -runstate_set. */ +multifd_load_cleanup ();dirty_bitmap_mig_before_vm_start ();
@@ -665,9 +659,9 @@ fail:migrate_set_state (&mis->state,MIGRATION_STATUS_ACTIVE ,MIGRATION_STATUS_FAILED );qemu_fclose (mis->from_src_file); -if (multifd_load_cleanup (&local_err) !=0 ) { -error_report_err (local_err); - } + +multifd_load_cleanup (); +exit (EXIT_FAILURE ); }
migration/multifd.c +2 -4
@@ -1013,12 +1013,12 @@ static void multifd_recv_terminate_threads(Error *err) } } -int multifd_load_cleanup (Error **errp) +void multifd_load_cleanup (void ) {int i;if (!migrate_use_multifd ()) { -return 0 ; +return ; }multifd_recv_terminate_threads (NULL );for (i =0 ; i <migrate_multifd_channels (); i++) {
@@ -1058,8 +1058,6 @@ int multifd_load_cleanup(Error **errp) multifd_recv_state->params =NULL ;g_free (multifd_recv_state); multifd_recv_state =NULL ; - -return 0 ; }void multifd_recv_sync_main (void )
Signature · 1 line
2.39.1
Juan Quintela
NAKQuoted 1 line · Xxx Xx
From: Juan Quintela <[email protected]>
Nack
Misses Fixes: label by leanardo
Sorry.
Quoted 114 lines
The following changes since commit
3b33ae48ec28e1e0d1bc28a85c7423724bcb1a2c:Merge tag 'block-pull-request' of https://gitlab.com/stefanha/qemu into staging (2023-02-09 15:29:14 +0000)
are available in the Git repository at:
https://gitlab.com/juan.quintela/qemu.git tags/migration-20230213-pull-request
for you to fetch changes up to
24f3e8188c13e5a8b9ad6f2a353f7d0cf80f461c:ram: Document migration ram flags (2023-02-13 02:58:26 +0100)
----------------------------------------------------------------
Migration Pull request (take2)Hi
In this PULL request:
- rebase to latest upstream
- fix compilation of linux-user (ifhave_systemwas missing) (me)
- cleanupmultifd_load_cleanup(leonardo)
- Document RAM flags (me)Please apply.
[take 1]
This are all the reviewed patches for migration:
- AVX512 support for xbzrle (Ling Xu)
-/dev/userfaultdsupport (Peter Xu)
- Improve ordering of channels (Peter Xu)
- multifd cleanups (Li Zhang)
- Remove spurious files from last merge (me) Rebase makes that to you
- Fix mixup between state_pending_{exact,estimate} (me)
- Cache RAM size during migration (me)
- cleanup several functions (me)Please apply.
----------------------------------------------------------------
Juan Quintela (8):
migration: Remove spurious files
migration: Simplifyram_find_and_save_block()
migration: Makefind_dirty_block()return a single parameter
migration: Splitram_bytes_total_common()in two functions
migration: Calculate ram size once
migration: Makeram_save_target_page()a pointer
migration: I messed state_pending_exact/estimate
ram: Document migration ram flagsLeonardo Bras (4):
migration/multifd: Changemultifd_load_cleanup()signature and usage migration/multifd: Remove unnecessary assignment on
multifd_load_cleanup()
migration/multifd: Join all multifd threads in order to avoid leaks migration/multifd: Moveload_cleanupinsideincoming_state_destroyLi Zhang (2):
multifd: cleanup the functionmultifd_channel_connect
multifd: Remove some redundant codePeter Xu (6):
linux-headers: Update to v6.1
util/userfaultfd: Support/dev/userfaultfd
migration: Rework multi-channel checks on URI
migration: Cleanuppostcopy_preempt_setup()
migration: Add a semaphore to count PONGs
migration: Postpone postcopy preempt channel to be after mainling xu (2):
AVX512 support forxbzrle_encode_buffer
Update bench-code for addressing CI problem.../x86_64-quintela-devices.mak | 7 - .../x86_64-quintela2-devices.mak | 6 - meson.build | 17 + include/standard-headers/drm/drm_fourcc.h | 34 +- include/standard-headers/linux/ethtool.h | 63 +- include/standard-headers/linux/fuse.h | 6 +- .../linux/input-event-codes.h | 1 + include/standard-headers/linux/virtio_blk.h | 19 + linux-headers/asm-generic/hugetlb_encode.h | 26 +- linux-headers/asm-generic/mman-common.h | 2 + linux-headers/asm-mips/mman.h | 2 + linux-headers/asm-riscv/kvm.h | 4 + linux-headers/linux/kvm.h | 1 + linux-headers/linux/psci.h | 14 + linux-headers/linux/userfaultfd.h | 4 + linux-headers/linux/vfio.h | 142 ++ migration/migration.h | 15 +- migration/multifd.h | 3 +- migration/postcopy-ram.h | 4 +- migration/xbzrle.h | 4 + migration/migration.c | 138 +- migration/multifd.c | 87 +- migration/postcopy-ram.c | 31 +- migration/ram.c | 148 +- migration/savevm.c | 56 +- migration/xbzrle.c | 124 ++ tests/bench/xbzrle-bench.c | 469 ++++++ tests/unit/test-xbzrle.c | 39 +- util/userfaultfd.c | 32 + meson_options.txt | 2 + migration/multifd.c.orig | 1274 ----------------- scripts/meson-buildoptions.sh | 3 + tests/bench/meson.build | 6 + util/trace-events | 1 + 34 files changed, 1278 insertions(+), 1506 deletions(-) delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela-devices.mak delete mode 100644 configs/devices/x86_64-softmmu/x86_64-quintela2-devices.mak create mode 100644 tests/bench/xbzrle-bench.c delete mode 100644 migration/multifd.c.orig