qemu/migration/multifd-nocomp.c
Prasad Pandit e274188612 migration: enable multifd and postcopy together
Enable Multifd and Postcopy migration together.
The migration_ioc_process_incoming() routine checks
magic value sent on each channel and helps to properly
setup multifd and postcopy channels.

The Precopy and Multifd threads work during the initial
guest RAM transfer. When migration moves to the Postcopy
phase, the multifd threads cease to send data on multifd
channels and Postcopy threads on the destination
request/pull data from the source side.

Reviewed-by: Fabiano Rosas <farosas@suse.de>
Signed-off-by: Prasad Pandit <pjp@fedoraproject.org>
Link: https://lore.kernel.org/r/20250512125124.147064-3-ppandit@redhat.com
Signed-off-by: Peter Xu <peterx@redhat.com>
2025-05-20 11:26:32 -04:00

468 lines
12 KiB
C

/*
* Multifd RAM migration without compression
*
* Copyright (c) 2019-2020 Red Hat Inc
*
* Authors:
* Juan Quintela <quintela@redhat.com>
*
* 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 "system/ramblock.h"
#include "exec/target_page.h"
#include "file.h"
#include "migration-stats.h"
#include "multifd.h"
#include "options.h"
#include "migration.h"
#include "qapi/error.h"
#include "qemu/cutils.h"
#include "qemu/error-report.h"
#include "trace.h"
#include "qemu-file.h"
static MultiFDSendData *multifd_ram_send;
void multifd_ram_payload_alloc(MultiFDPages_t *pages)
{
pages->offset = g_new0(ram_addr_t, multifd_ram_page_count());
}
void multifd_ram_payload_free(MultiFDPages_t *pages)
{
g_clear_pointer(&pages->offset, g_free);
}
void multifd_ram_save_setup(void)
{
multifd_ram_send = multifd_send_data_alloc();
}
void multifd_ram_save_cleanup(void)
{
g_clear_pointer(&multifd_ram_send, multifd_send_data_free);
}
static void multifd_set_file_bitmap(MultiFDSendParams *p)
{
MultiFDPages_t *pages = &p->data->u.ram;
assert(pages->block);
for (int i = 0; i < pages->normal_num; i++) {
ramblock_set_file_bmap_atomic(pages->block, pages->offset[i], true);
}
for (int i = pages->normal_num; i < pages->num; i++) {
ramblock_set_file_bmap_atomic(pages->block, pages->offset[i], false);
}
}
static int multifd_nocomp_send_setup(MultiFDSendParams *p, Error **errp)
{
uint32_t page_count = multifd_ram_page_count();
if (migrate_zero_copy_send()) {
p->write_flags |= QIO_CHANNEL_WRITE_FLAG_ZERO_COPY;
}
if (!migrate_mapped_ram()) {
/* We need one extra place for the packet header */
p->iov = g_new0(struct iovec, page_count + 1);
} else {
p->iov = g_new0(struct iovec, page_count);
}
return 0;
}
static void multifd_nocomp_send_cleanup(MultiFDSendParams *p, Error **errp)
{
g_free(p->iov);
p->iov = NULL;
}
static void multifd_ram_prepare_header(MultiFDSendParams *p)
{
p->iov[0].iov_len = p->packet_len;
p->iov[0].iov_base = p->packet;
p->iovs_num++;
}
static void multifd_send_prepare_iovs(MultiFDSendParams *p)
{
MultiFDPages_t *pages = &p->data->u.ram;
uint32_t page_size = multifd_ram_page_size();
for (int i = 0; i < pages->normal_num; i++) {
p->iov[p->iovs_num].iov_base = pages->block->host + pages->offset[i];
p->iov[p->iovs_num].iov_len = page_size;
p->iovs_num++;
}
p->next_packet_size = pages->normal_num * page_size;
}
static int multifd_nocomp_send_prepare(MultiFDSendParams *p, Error **errp)
{
bool use_zero_copy_send = migrate_zero_copy_send();
int ret;
multifd_send_zero_page_detect(p);
if (migrate_mapped_ram()) {
multifd_send_prepare_iovs(p);
multifd_set_file_bitmap(p);
return 0;
}
if (!use_zero_copy_send) {
/*
* Only !zerocopy needs the header in IOV; zerocopy will
* send it separately.
*/
multifd_ram_prepare_header(p);
}
multifd_send_prepare_iovs(p);
p->flags |= MULTIFD_FLAG_NOCOMP;
multifd_send_fill_packet(p);
if (use_zero_copy_send) {
/* Send header first, without zerocopy */
ret = qio_channel_write_all(p->c, (void *)p->packet,
p->packet_len, errp);
if (ret != 0) {
return -1;
}
stat64_add(&mig_stats.multifd_bytes, p->packet_len);
}
return 0;
}
static int multifd_nocomp_recv_setup(MultiFDRecvParams *p, Error **errp)
{
p->iov = g_new0(struct iovec, multifd_ram_page_count());
return 0;
}
static void multifd_nocomp_recv_cleanup(MultiFDRecvParams *p)
{
g_free(p->iov);
p->iov = NULL;
}
static int multifd_nocomp_recv(MultiFDRecvParams *p, Error **errp)
{
uint32_t flags;
if (migrate_mapped_ram()) {
return multifd_file_recv_data(p, errp);
}
flags = p->flags & MULTIFD_FLAG_COMPRESSION_MASK;
if (flags != MULTIFD_FLAG_NOCOMP) {
error_setg(errp, "multifd %u: flags received %x flags expected %x",
p->id, flags, MULTIFD_FLAG_NOCOMP);
return -1;
}
multifd_recv_zero_page_process(p);
if (!p->normal_num) {
return 0;
}
for (int i = 0; i < p->normal_num; i++) {
p->iov[i].iov_base = p->host + p->normal[i];
p->iov[i].iov_len = multifd_ram_page_size();
ramblock_recv_bitmap_set_offset(p->block, p->normal[i]);
}
return qio_channel_readv_all(p->c, p->iov, p->normal_num, errp);
}
static void multifd_pages_reset(MultiFDPages_t *pages)
{
/*
* We don't need to touch offset[] array, because it will be
* overwritten later when reused.
*/
pages->num = 0;
pages->normal_num = 0;
pages->block = NULL;
}
void multifd_ram_fill_packet(MultiFDSendParams *p)
{
MultiFDPacket_t *packet = p->packet;
MultiFDPages_t *pages = &p->data->u.ram;
uint32_t zero_num = pages->num - pages->normal_num;
packet->pages_alloc = cpu_to_be32(multifd_ram_page_count());
packet->normal_pages = cpu_to_be32(pages->normal_num);
packet->zero_pages = cpu_to_be32(zero_num);
if (pages->block) {
pstrcpy(packet->ramblock, sizeof(packet->ramblock),
pages->block->idstr);
}
for (int i = 0; i < pages->num; i++) {
/* there are architectures where ram_addr_t is 32 bit */
uint64_t temp = pages->offset[i];
packet->offset[i] = cpu_to_be64(temp);
}
trace_multifd_send_ram_fill(p->id, pages->normal_num,
zero_num);
}
int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp)
{
MultiFDPacket_t *packet = p->packet;
uint32_t page_count = multifd_ram_page_count();
uint32_t page_size = multifd_ram_page_size();
uint32_t pages_per_packet = be32_to_cpu(packet->pages_alloc);
int i;
if (pages_per_packet > page_count) {
error_setg(errp, "multifd: received packet with %u pages, expected %u",
pages_per_packet, page_count);
return -1;
}
p->normal_num = be32_to_cpu(packet->normal_pages);
if (p->normal_num > pages_per_packet) {
error_setg(errp, "multifd: received packet with %u non-zero pages, "
"which exceeds maximum expected pages %u",
p->normal_num, pages_per_packet);
return -1;
}
p->zero_num = be32_to_cpu(packet->zero_pages);
if (p->zero_num > pages_per_packet - p->normal_num) {
error_setg(errp,
"multifd: received packet with %u zero pages, expected maximum %u",
p->zero_num, pages_per_packet - p->normal_num);
return -1;
}
if (p->normal_num == 0 && p->zero_num == 0) {
return 0;
}
/* make sure that ramblock is 0 terminated */
packet->ramblock[255] = 0;
p->block = qemu_ram_block_by_name(packet->ramblock);
if (!p->block) {
error_setg(errp, "multifd: unknown ram block %s",
packet->ramblock);
return -1;
}
p->host = p->block->host;
for (i = 0; i < p->normal_num; i++) {
uint64_t offset = be64_to_cpu(packet->offset[i]);
if (offset > (p->block->used_length - page_size)) {
error_setg(errp, "multifd: offset too long %" PRIu64
" (max " RAM_ADDR_FMT ")",
offset, p->block->used_length);
return -1;
}
p->normal[i] = offset;
}
for (i = 0; i < p->zero_num; i++) {
uint64_t offset = be64_to_cpu(packet->offset[p->normal_num + i]);
if (offset > (p->block->used_length - page_size)) {
error_setg(errp, "multifd: offset too long %" PRIu64
" (max " RAM_ADDR_FMT ")",
offset, p->block->used_length);
return -1;
}
p->zero[i] = offset;
}
return 0;
}
static inline bool multifd_queue_empty(MultiFDPages_t *pages)
{
return pages->num == 0;
}
static inline bool multifd_queue_full(MultiFDPages_t *pages)
{
return pages->num == multifd_ram_page_count();
}
static inline void multifd_enqueue(MultiFDPages_t *pages, ram_addr_t offset)
{
pages->offset[pages->num++] = offset;
}
/* Returns true if enqueue successful, false otherwise */
bool multifd_queue_page(RAMBlock *block, ram_addr_t offset)
{
MultiFDPages_t *pages;
retry:
pages = &multifd_ram_send->u.ram;
if (multifd_payload_empty(multifd_ram_send)) {
multifd_pages_reset(pages);
multifd_set_payload_type(multifd_ram_send, MULTIFD_PAYLOAD_RAM);
}
/* If the queue is empty, we can already enqueue now */
if (multifd_queue_empty(pages)) {
pages->block = block;
multifd_enqueue(pages, offset);
return true;
}
/*
* Not empty, meanwhile we need a flush. It can because of either:
*
* (1) The page is not on the same ramblock of previous ones, or,
* (2) The queue is full.
*
* After flush, always retry.
*/
if (pages->block != block || multifd_queue_full(pages)) {
if (!multifd_send(&multifd_ram_send)) {
return false;
}
goto retry;
}
/* Not empty, and we still have space, do it! */
multifd_enqueue(pages, offset);
return true;
}
/*
* We have two modes for multifd flushes:
*
* - Per-section mode: this is the legacy way to flush, it requires one
* MULTIFD_FLAG_SYNC message for each RAM_SAVE_FLAG_EOS.
*
* - Per-round mode: this is the modern way to flush, it requires one
* MULTIFD_FLAG_SYNC message only for each round of RAM scan. Normally
* it's paired with a new RAM_SAVE_FLAG_MULTIFD_FLUSH message in network
* based migrations.
*
* One thing to mention is mapped-ram always use the modern way to sync.
*/
/* Do we need a per-section multifd flush (legacy way)? */
bool multifd_ram_sync_per_section(void)
{
if (!migrate_multifd()) {
return false;
}
if (migrate_mapped_ram()) {
return false;
}
return migrate_multifd_flush_after_each_section();
}
/* Do we need a per-round multifd flush (modern way)? */
bool multifd_ram_sync_per_round(void)
{
if (!migrate_multifd()) {
return false;
}
if (migrate_mapped_ram()) {
return true;
}
return !migrate_multifd_flush_after_each_section();
}
int multifd_ram_flush_and_sync(QEMUFile *f)
{
MultiFDSyncReq req;
int ret;
if (!migrate_multifd() || migration_in_postcopy()) {
return 0;
}
if (!multifd_payload_empty(multifd_ram_send)) {
if (!multifd_send(&multifd_ram_send)) {
error_report("%s: multifd_send fail", __func__);
return -1;
}
}
/* File migrations only need to sync with threads */
req = migrate_mapped_ram() ? MULTIFD_SYNC_LOCAL : MULTIFD_SYNC_ALL;
ret = multifd_send_sync_main(req);
if (ret) {
return ret;
}
/* If we don't need to sync with remote at all, nothing else to do */
if (req == MULTIFD_SYNC_LOCAL) {
return 0;
}
/*
* Old QEMUs don't understand RAM_SAVE_FLAG_MULTIFD_FLUSH, it relies
* on RAM_SAVE_FLAG_EOS instead.
*/
if (migrate_multifd_flush_after_each_section()) {
return 0;
}
qemu_put_be64(f, RAM_SAVE_FLAG_MULTIFD_FLUSH);
qemu_fflush(f);
return 0;
}
bool multifd_send_prepare_common(MultiFDSendParams *p)
{
MultiFDPages_t *pages = &p->data->u.ram;
multifd_ram_prepare_header(p);
multifd_send_zero_page_detect(p);
if (!pages->normal_num) {
p->next_packet_size = 0;
return false;
}
return true;
}
static const MultiFDMethods multifd_nocomp_ops = {
.send_setup = multifd_nocomp_send_setup,
.send_cleanup = multifd_nocomp_send_cleanup,
.send_prepare = multifd_nocomp_send_prepare,
.recv_setup = multifd_nocomp_recv_setup,
.recv_cleanup = multifd_nocomp_recv_cleanup,
.recv = multifd_nocomp_recv
};
static void multifd_nocomp_register(void)
{
multifd_register_ops(MULTIFD_COMPRESSION_NONE, &multifd_nocomp_ops);
}
migration_init(multifd_nocomp_register);