migration/multifd: Remove multifd_send_state->pages
Subsystems (2)
v5 cover migration/multifd: Remove multifd_send_state->pages
Hi, thank you all for the reviews. One more version to address a couple of cleanups suggested by Philippe.
CI run: https://gitlab.com/farosas/qemu/-/pipelines/1427843439
Thanks
================================================================
v4:
https://lore.kernel.org/r/[email protected]
Not much changed sinced v3, the most notable is that I kept the nocomp names and created multifd-nocomp.c. I think "plain" is even more misterious, so let's keep what we are already used to.
CI run: https://gitlab.com/farosas/qemu/-/pipelines/1425141484
v3:
https://lore.kernel.org/r/[email protected]
This v3 incorporates the suggestions done by Peter in v2. Aside from those, of note:
- fixed the allocation of MultiFDSendData. The previous version didn't account for compiler-inserted holes;
- kept the packet split patch;
- added some patches to remove p->page_count, p->page_size, pages->allocated. These are all constants and don't need to be per-channel;
- moved the code into multifd-ram.c.
However, I left the p->packet allocation (depends on page_count) and p->normal + p->zero behind because I need to see how the device state patches will deal with the packet stuff before I can come up with a way to move those out of the MultiFD*Params. It might not be worth it adding another struct just for the ram code to store p->normal, p->zero.
With this I'm pretty much done with what I think needs to be changed as a prereq for the device state work. I don't have anything else in mind to add to this series.
CI run: https://gitlab.com/farosas/qemu/-/pipelines/1395572680
v2:
https://lore.kernel.org/r/[email protected]
v1:
https://lore.kernel.org/r/[email protected]
First of all, apologies for the roughness of the series. I'm off for the next couple of weeks and wanted to put something together early for your consideration.
This series is a refactoring (based on an earlier, off-list attempt[0]), aimed to remove the usage of the MultiFDPages_t type in the multifd core. If we're going to add support for more data types to multifd, we first need to clean that up.
This time around this work was prompted by Maciej's series[1]. I see you're having to add a bunch of is_device_state checks to work around the rigidity of the code.
Aside from the VFIO work, there is also the intent (coming back from Juan's ideas) to make multifd the default code path for migration, which will have to include the vmstate migration and anything else we put on the stream via QEMUFile.
I have long since been bothered by having 'pages' sprinkled all over the code, so I might be coming at this with a bit of a narrow focus, but I believe in order to support more types of payloads in multifd, we need to first allow the scheduling at multifd_send_pages() to be independent of MultiFDPages_t. So here it is. Let me know what you think.
(as I said, I'll be off for a couple of weeks, so feel free to incorporate any of this code if it's useful. Or to ignore it completely).
CI run: https://gitlab.com/farosas/qemu/-/pipelines/1340992028
0- https://github.com/farosas/qemu/commits/multifd-packet-cleanups/
1- https://lore.kernel.org/r/[email protected]
Fabiano Rosas (18):
migration/multifd: Reduce access to p->pages migration/multifd: Inline page_size and page_count migration/multifd: Remove pages->allocated migration/multifd: Pass in MultiFDPages_t to file_write_ramblock_iov migration/multifd: Introduce MultiFDSendData migration/multifd: Make MultiFDPages_t:offset a flexible array member migration/multifd: Replace p->pages with an union pointer migration/multifd: Move pages accounting into
multifd_send_zero_page_detect()
migration/multifd: Remove total pages tracing migration/multifd: Isolate ram pages packet data migration/multifd: Don't send ram data during SYNC migration/multifd: Replace multifd_send_state->pages with client data migration/multifd: Allow multifd sync without flush migration/multifd: Standardize on multifd ops names migration/multifd: Register nocomp ops dynamically migration/multifd: Move nocomp code into multifd-nocomp.c migration/multifd: Make MultiFDMethods const migration/multifd: Stop changing the packet on recv side
migration/file.c | 3 +- migration/file.h | 2 +- migration/meson.build | 1 + migration/multifd-nocomp.c | 388 ++++++++++++++++++++++++ migration/multifd-qpl.c | 79 +---- migration/multifd-uadk.c | 102 ++----- migration/multifd-zero-page.c | 13 +- migration/multifd-zlib.c | 99 ++---- migration/multifd-zstd.c | 98 ++---- migration/multifd.c | 555 ++++++---------------------------- migration/multifd.h | 76 +++-- migration/ram.c | 10 +- migration/trace-events | 9 +- 13 files changed, 638 insertions(+), 797 deletions(-) create mode 100644 migration/multifd-nocomp.c
Signature · 1 line
2.35.3
PATCH v5 1/18 migration/multifd: Reduce access to p->pages
I'm about to replace the p->pages pointer with an opaque pointer, so do a cleanup now to reduce direct accesses to p->page, which makes the next diffs cleaner.
--- migration/multifd-qpl.c | 8 +++++--- migration/multifd-uadk.c | 9 +++++---- migration/multifd-zlib.c | 2 +- migration/multifd-zstd.c | 2 +- migration/multifd.c | 13 +++++++------ 5 files changed, 19 insertions(+), 15 deletions(-)
migration/multifd-qpl.c +5 -3
@@ -404,13 +404,14 @@ retry:static void multifd_qpl_compress_pages_slow_path (MultiFDSendParams *p) {QplData *qpl = p->compress_data; +MultiFDPages_t *pages = p->pages;uint32_t size = p->page_size;qpl_job *job = qpl->sw_job;uint8_t *zbuf = qpl->zbuf;uint8_t *buf; -for (int i =0 ; i < p->pages->normal_num; i++) { - buf = p->pages->block->host + p->pages->offset[i]; +for (int i =0 ; i < pages->normal_num; i++) { + buf = pages->block->host + pages->offset[i];multifd_qpl_prepare_comp_job (job, buf, zbuf, size);if (qpl_execute_job (job) ==QPL_STS_OK ) {multifd_qpl_fill_packet (i, p, zbuf, job->total_out);
@@ -498,6 +499,7 @@ static void multifd_qpl_compress_pages(MultiFDSendParams *p)static int multifd_qpl_send_prepare (MultiFDSendParams *p,Error **errp) {QplData *qpl = p->compress_data; +MultiFDPages_t *pages = p->pages;uint32_t len =0 ;if (!multifd_send_prepare_common (p)) {
@@ -505,7 +507,7 @@ static int multifd_qpl_send_prepare(MultiFDSendParams *p, Error **errp) }/* The first IOV is used to store the compressed page lengths */ - len = p->pages->normal_num *sizeof (uint32_t ); + len = pages->normal_num *sizeof (uint32_t );multifd_qpl_fill_iov (p, (uint8_t *) qpl->zlen, len);if (qpl->hw_avail) {multifd_qpl_compress_pages (p);
migration/multifd-uadk.c +5 -4
@@ -174,19 +174,20 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)uint32_t hdr_size;uint8_t *buf = uadk_data->buf;int ret =0 ; +MultiFDPages_t *pages = p->pages;if (!multifd_send_prepare_common (p)) { goto out; } - hdr_size = p->pages->normal_num *sizeof (uint32_t ); + hdr_size = pages->normal_num *sizeof (uint32_t );/* prepare the header that stores the lengths of all compressed data */ prepare_next_iov (p, uadk_data->buf_hdr, hdr_size); -for (int i =0 ; i < p->pages->normal_num; i++) { +for (int i =0 ; i < pages->normal_num; i++) {struct wd_comp_req creq = { .op_type =WD_DIR_COMPRESS , - .src = p->pages->block->host + p->pages->offset[i], + .src = pages->block->host + pages->offset[i], .src_len = p->page_size, .dst = buf,/* Set dst_len to double the src in case compressed out >= page_size */
@@ -214,7 +215,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)*/ if (!uadk_data->handle || creq.dst_len >= p->page_size) { uadk_data->buf_hdr[i] =cpu_to_be32 (p->page_size); -prepare_next_iov (p, p->pages->block->host + p->pages->offset[i], +prepare_next_iov (p, pages->block->host + pages->offset[i], p->page_size); buf += p->page_size; }
migration/multifd-zlib.c +1 -1
@@ -147,7 +147,7 @@ static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)* with compression. zlib does not guarantee that this is safe, * therefore copy the page before calling deflate(). */ -memcpy (z->buf, p->pages->block->host + pages->offset[i], p->page_size); +memcpy (z->buf, pages->block->host + pages->offset[i], p->page_size); zs->avail_in = p->page_size; zs->next_in = z->buf;
migration/multifd-zstd.c +1 -1
@@ -138,7 +138,7 @@ static int zstd_send_prepare(MultiFDSendParams *p, Error **errp)if (i == pages->normal_num -1 ) { flush = ZSTD_e_flush; } - z->in.src = p->pages->block->host + pages->offset[i]; + z->in.src = pages->block->host + pages->offset[i]; z->in.size = p->page_size; z->in.pos =0 ;
migration/multifd.c +7 -6
@@ -114,11 +114,11 @@ static void multifd_set_file_bitmap(MultiFDSendParams *p)assert (pages->block); -for (int i =0 ; i < p->pages->normal_num; i++) { +for (int i =0 ; i < pages->normal_num; i++) {ramblock_set_file_bmap_atomic (pages->block, pages->offset[i], true); } -for (int i = p->pages->normal_num; i < p->pages->num; i++) { +for (int i = pages->normal_num; i < pages->num; i++) {ramblock_set_file_bmap_atomic (pages->block, pages->offset[i], false); } }
@@ -417,7 +417,7 @@ void multifd_send_fill_packet(MultiFDSendParams *p)int i; packet->flags =cpu_to_be32 (p->flags); - packet->pages_alloc =cpu_to_be32 (p->pages->allocated); + packet->pages_alloc =cpu_to_be32 (pages->allocated); packet->normal_pages =cpu_to_be32 (pages->normal_num); packet->zero_pages =cpu_to_be32 (zero_num); packet->next_packet_size =cpu_to_be32 (p->next_packet_size);
@@ -953,7 +953,7 @@ static void *multifd_send_thread(void *opaque)if (migrate_mapped_ram ()) { ret =file_write_ramblock_iov (p->c, p->iov, p->iovs_num, - p->pages->block, &local_err); + pages->block, &local_err); }else { ret = qio_channel_writev_full_all(p->c, p->iov, p->iovs_num, NULL, 0, p->write_flags,
@@ -969,7 +969,7 @@ static void *multifd_send_thread(void *opaque)stat64_add (&mig_stats.normal_pages, pages->normal_num);stat64_add (&mig_stats.zero_pages, pages->num - pages->normal_num); -multifd_pages_reset (p->pages); +multifd_pages_reset (pages); p->next_packet_size =0 ;/*
@@ -1690,9 +1690,10 @@ void multifd_recv_new_channel(QIOChannel *ioc, Error **errp)bool multifd_send_prepare_common (MultiFDSendParams *p) { +MultiFDPages_t *pages = p->pages;multifd_send_zero_page_detect (p); -if (!p->pages->normal_num) { +if (!pages->normal_num) { p->next_packet_size =0 ;return false; }
Signature · 1 line
2.35.3
PATCH v5 2/18 migration/multifd: Inline page_size and page_count
In reply to Fabiano RosasThe MultiFD*Params structures are for per-channel data. Constant values should not be there because that needlessly wastes cycles and storage. The page_size and page_count fall into this category so move them inline in multifd.h.
--- migration/multifd-qpl.c | 10 +++++++--- migration/multifd-uadk.c | 36 ++++++++++++++++++++--------------- migration/multifd-zero-page.c | 4 ++-- migration/multifd-zlib.c | 14 ++++++++------ migration/multifd-zstd.c | 11 ++++++----- migration/multifd.c | 33 ++++++++++++++++---------------- migration/multifd.h | 18 ++++++++++-------- 7 files changed, 71 insertions(+), 55 deletions(-)
migration/multifd-qpl.c +7 -3
@@ -233,8 +233,10 @@ static void multifd_qpl_deinit(QplData *qpl)static int multifd_qpl_send_setup (MultiFDSendParams *p,Error **errp) {QplData *qpl; +uint32_t page_size =multifd_ram_page_size (); +uint32_t page_count =multifd_ram_page_count (); - qpl =multifd_qpl_init (p->page_count, p->page_size, errp); + qpl =multifd_qpl_init (page_count, page_size, errp);if (!qpl) {return -1 ; }
@@ -245,7 +247,7 @@ static int multifd_qpl_send_setup(MultiFDSendParams *p, Error **errp)* additional two IOVs are used to store packet header and compressed data * length */ - p->iov = g_new0(struct iovec, p->page_count + 2); + p->iov = g_new0(struct iovec, page_count + 2);return 0 ; }
@@ -534,8 +536,10 @@ out:static int multifd_qpl_recv_setup (MultiFDRecvParams *p,Error **errp) {QplData *qpl; +uint32_t page_size =multifd_ram_page_size (); +uint32_t page_count =multifd_ram_page_count (); - qpl =multifd_qpl_init (p->page_count, p->page_size, errp); + qpl =multifd_qpl_init (page_count, page_size, errp);if (!qpl) {return -1 ; }
migration/multifd-uadk.c +21 -15
@@ -114,8 +114,10 @@ static void multifd_uadk_uninit_sess(struct wd_data *wd)static int multifd_uadk_send_setup (MultiFDSendParams *p,Error **errp) {struct wd_data *wd; +uint32_t page_size =multifd_ram_page_size (); +uint32_t page_count =multifd_ram_page_count (); - wd =multifd_uadk_init_sess (p->page_count, p->page_size, true, errp); + wd =multifd_uadk_init_sess (page_count, page_size, true, errp);if (!wd) {return -1 ; }
@@ -128,7 +130,7 @@ static int multifd_uadk_send_setup(MultiFDSendParams *p, Error **errp)* length */ - p->iov = g_new0(struct iovec, p->page_count + 2); + p->iov = g_new0(struct iovec, page_count + 2);return 0 ; }
@@ -172,6 +174,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp) {struct wd_data *uadk_data = p->compress_data;uint32_t hdr_size; +uint32_t page_size =multifd_ram_page_size ();uint8_t *buf = uadk_data->buf;int ret =0 ;MultiFDPages_t *pages = p->pages;
@@ -188,7 +191,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)struct wd_comp_req creq = { .op_type =WD_DIR_COMPRESS , .src = pages->block->host + pages->offset[i], - .src_len = p->page_size, + .src_len = page_size, .dst = buf,/* Set dst_len to double the src in case compressed out >= page_size */ .dst_len = p->page_size *2 ,
@@ -201,7 +204,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp) p->id, ret, creq.status);return -1 ; } -if (creq.dst_len < p->page_size) { +if (creq.dst_len < page_size) { uadk_data->buf_hdr[i] =cpu_to_be32 (creq.dst_len);prepare_next_iov (p, buf, creq.dst_len); buf += creq.dst_len;
@@ -213,11 +216,11 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)* than page_size as well because at the receive end we can skip the * decompression. But it is tricky to find the right number here. */ -if (!uadk_data->handle || creq.dst_len >= p->page_size) { - uadk_data->buf_hdr[i] =cpu_to_be32 (p->page_size); +if (!uadk_data->handle || creq.dst_len >= page_size) { + uadk_data->buf_hdr[i] =cpu_to_be32 (page_size);prepare_next_iov (p, pages->block->host + pages->offset[i], - p->page_size); - buf += p->page_size; + page_size); + buf += page_size; } } out:
@@ -239,8 +242,10 @@ out:static int multifd_uadk_recv_setup (MultiFDRecvParams *p,Error **errp) {struct wd_data *wd; +uint32_t page_size =multifd_ram_page_size (); +uint32_t page_count =multifd_ram_page_count (); - wd =multifd_uadk_init_sess (p->page_count, p->page_size, false, errp); + wd =multifd_uadk_init_sess (page_count, page_size, false, errp);if (!wd) {return -1 ; }
@@ -281,6 +286,7 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp)uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ;uint32_t hdr_len = p->normal_num *sizeof (uint32_t );uint32_t data_len =0 ; +uint32_t page_size =multifd_ram_page_size ();uint8_t *buf = uadk_data->buf;int ret =0 ;
@@ -307,7 +313,7 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp)for (int i =0 ; i < p->normal_num; i++) { uadk_data->buf_hdr[i] =be32_to_cpu (uadk_data->buf_hdr[i]); data_len += uadk_data->buf_hdr[i]; -assert (uadk_data->buf_hdr[i] <= p->page_size); +assert (uadk_data->buf_hdr[i] <= page_size); }/* read compressed data */
@@ -323,12 +329,12 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp) .src = buf, .src_len = uadk_data->buf_hdr[i], .dst = p->host + p->normal[i], - .dst_len = p->page_size, + .dst_len = page_size, }; -if (uadk_data->buf_hdr[i] == p->page_size) { -memcpy (p->host + p->normal[i], buf, p->page_size); - buf += p->page_size; +if (uadk_data->buf_hdr[i] == page_size) { +memcpy (p->host + p->normal[i], buf, page_size); + buf += page_size;continue ; }
@@ -344,7 +350,7 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp) p->id, ret, creq.status);return -1 ; } -if (creq.dst_len != p->page_size) { +if (creq.dst_len != page_size) {error_setg (errp,"multifd %u: decompressed length error" , p->id);return -1 ; }
migration/multifd-zero-page.c +2 -2
@@ -63,7 +63,7 @@ void multifd_send_zero_page_detect(MultiFDSendParams *p)while (i <= j) {uint64_t offset = pages->offset[i]; -if (!buffer_is_zero (rb->host + offset, p->page_size)) { +if (!buffer_is_zero (rb->host + offset,multifd_ram_page_size ())) { i++;continue ; }
@@ -81,7 +81,7 @@ void multifd_recv_zero_page_process(MultiFDRecvParams *p)for (int i =0 ; i < p->zero_num; i++) {void *page = p->host + p->zero[i];if (ramblock_recv_bitmap_test_byte_offset (p->block, p->zero[i])) { -memset (page,0 , p->page_size); +memset (page,0 ,multifd_ram_page_size ()); }else {ramblock_recv_bitmap_set_offset (p->block, p->zero[i]); }
migration/multifd-zlib.c +8 -6
@@ -127,6 +127,7 @@ static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)struct zlib_data *z = p->compress_data;z_stream *zs = &z->zs;uint32_t out_size =0 ; +uint32_t page_size =multifd_ram_page_size ();int ret;uint32_t i;
@@ -147,8 +148,8 @@ static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)* with compression. zlib does not guarantee that this is safe, * therefore copy the page before calling deflate(). */ -memcpy (z->buf, pages->block->host + pages->offset[i], p->page_size); - zs->avail_in = p->page_size; +memcpy (z->buf, pages->block->host + pages->offset[i], page_size); + zs->avail_in = page_size; zs->next_in = z->buf; zs->avail_out = available;
@@ -260,7 +261,8 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp)uint32_t in_size = p->next_packet_size;/* we measure the change of total_out */ uint32_t out_size = zs->total_out; -uint32_t expected_size = p->normal_num * p->page_size; +uint32_t page_size =multifd_ram_page_size (); +uint32_t expected_size = p->normal_num * page_size;uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ;int ret;int i;
@@ -296,7 +298,7 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp) flush =Z_SYNC_FLUSH ; } - zs->avail_out = p->page_size; + zs->avail_out = page_size; zs->next_out = p->host + p->normal[i];/*
@@ -310,8 +312,8 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp)do { ret =inflate (zs, flush); }while (ret ==Z_OK && zs->avail_in - && (zs->total_out - start) < p->page_size); -if (ret ==Z_OK && (zs->total_out - start) < p->page_size) { + && (zs->total_out - start) < page_size); +if (ret ==Z_OK && (zs->total_out - start) < page_size) {error_setg (errp,"multifd %u: inflate generated too few output" , p->id);return -1 ;
migration/multifd-zstd.c +6 -5
@@ -139,7 +139,7 @@ static int zstd_send_prepare(MultiFDSendParams *p, Error **errp) flush = ZSTD_e_flush; } z->in.src = pages->block->host + pages->offset[i]; - z->in.size = p->page_size; + z->in.size =multifd_ram_page_size (); z->in.pos =0 ;/*
@@ -254,7 +254,8 @@ static int zstd_recv(MultiFDRecvParams *p, Error **errp) {uint32_t in_size = p->next_packet_size;uint32_t out_size =0 ; -uint32_t expected_size = p->normal_num * p->page_size; +uint32_t page_size =multifd_ram_page_size (); +uint32_t expected_size = p->normal_num * page_size;uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ;struct zstd_data *z = p->compress_data;int ret;
@@ -286,7 +287,7 @@ static int zstd_recv(MultiFDRecvParams *p, Error **errp)for (i =0 ; i < p->normal_num; i++) {ramblock_recv_bitmap_set_offset (p->block, p->normal[i]); z->out.dst = p->host + p->normal[i]; - z->out.size = p->page_size; + z->out.size = page_size; z->out.pos =0 ;/*
@@ -300,8 +301,8 @@ static int zstd_recv(MultiFDRecvParams *p, Error **errp)do { ret =ZSTD_decompressStream (z->zds, &z->out, &z->in); }while (ret >0 && (z->in.size - z->in.pos >0 ) - && (z->out.pos < p->page_size)); -if (ret >0 && (z->out.pos < p->page_size)) { + && (z->out.pos < page_size)); +if (ret >0 && (z->out.pos < page_size)) {error_setg (errp,"multifd %u: decompressStream buffer too small" , p->id);return -1 ;
migration/multifd.c +17 -16
@@ -133,15 +133,17 @@ static void multifd_set_file_bitmap(MultiFDSendParams *p)*/ static int 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 (multifd_use_packets ()) {/* We need one extra place for the packet header */ - p->iov = g_new0(struct iovec, p->page_count + 1); + p->iov = g_new0(struct iovec, page_count + 1); }else { - p->iov = g_new0(struct iovec, p->page_count); + p->iov = g_new0(struct iovec, page_count); }return 0 ;
@@ -165,14 +167,15 @@ static void nocomp_send_cleanup(MultiFDSendParams *p, Error **errp)static void multifd_send_prepare_iovs (MultiFDSendParams *p) {MultiFDPages_t *pages = p->pages; +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 = p->page_size; + p->iov[p->iovs_num].iov_len = page_size; p->iovs_num++; } - p->next_packet_size = pages->normal_num * p->page_size; + p->next_packet_size = pages->normal_num * page_size; }/**
@@ -237,7 +240,7 @@ static int nocomp_send_prepare(MultiFDSendParams *p, Error **errp)*/ static int nocomp_recv_setup (MultiFDRecvParams *p,Error **errp) { - p->iov = g_new0(struct iovec, p->page_count); + p->iov = g_new0(struct iovec, multifd_ram_page_count());return 0 ; }
@@ -288,7 +291,7 @@ static int nocomp_recv(MultiFDRecvParams *p, Error **errp)for (int i =0 ; i < p->normal_num; i++) { p->iov[i].iov_base = p->host + p->normal[i]; - p->iov[i].iov_len = p->page_size; + 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);
@@ -447,6 +450,8 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_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 ();int i; packet->magic =be32_to_cpu (packet->magic);
@@ -472,10 +477,10 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)* If we received a packet that is 100 times bigger than expected * just stop migration. It is a magic number. */ -if (packet->pages_alloc > p->page_count) { +if (packet->pages_alloc > page_count) {error_setg (errp,"multifd: received packet " "with size %u and expected a size of %u" , - packet->pages_alloc, p->page_count) ; + packet->pages_alloc, page_count) ;return -1 ; }
@@ -521,7 +526,7 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)for (i =0 ; i < p->normal_num; i++) {uint64_t offset =be64_to_cpu (packet->offset[i]); -if (offset > (p->block->used_length - p->page_size)) { +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);
@@ -533,7 +538,7 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)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 - p->page_size)) { +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);
@@ -1157,7 +1162,7 @@ bool multifd_send_setup(void) {MigrationState *s =migrate_get_current ();int thread_count, ret =0 ; -uint32_t page_count =MULTIFD_PACKET_SIZE /qemu_target_page_size (); +uint32_t page_count =multifd_ram_page_count ();bool use_packets =multifd_use_packets ();uint8_t i;
@@ -1191,8 +1196,6 @@ bool multifd_send_setup(void) p->packet->version =cpu_to_be32 (MULTIFD_VERSION ); } p->name =g_strdup_printf ("mig/src/send_%d" , i); - p->page_size =qemu_target_page_size (); - p->page_count = page_count; p->write_flags =0 ;if (!multifd_new_send_channel_create (p, &local_err)) {
@@ -1569,7 +1572,7 @@ static void *multifd_recv_thread(void *opaque)int multifd_recv_setup (Error **errp) {int thread_count; -uint32_t page_count =MULTIFD_PACKET_SIZE /qemu_target_page_size (); +uint32_t page_count =multifd_ram_page_count ();bool use_packets =multifd_use_packets ();uint8_t i;
@@ -1613,8 +1616,6 @@ int multifd_recv_setup(Error **errp) p->name =g_strdup_printf ("mig/dst/recv_%d" , i); p->normal =g_new0 (ram_addr_t, page_count); p->zero =g_new0 (ram_addr_t, page_count); - p->page_count = page_count; - p->page_size =qemu_target_page_size (); }for (i =0 ; i < thread_count; i++) {
migration/multifd.h +10 -8
@@ -13,6 +13,7 @@#ifndef QEMU_MIGRATION_MULTIFD_H #define QEMU_MIGRATION_MULTIFD_H +#include "exec/target_page.h" #include "ram.h" typedef struct MultiFDRecvData MultiFDRecvData ;
@@ -106,10 +107,6 @@ typedef struct {QIOChannel *c;/* packet allocated len */ uint32_t packet_len; -/* guest page size */ -uint32_t page_size; -/* number of pages in a full packet */ -uint32_t page_count;/* multifd flags for sending ram */ int write_flags;
@@ -173,10 +170,6 @@ typedef struct {QIOChannel *c;/* packet allocated len */ uint32_t packet_len; -/* guest page size */ -uint32_t page_size; -/* number of pages in a full packet */ -uint32_t page_count;/* syncs main thread and channels */ QemuSemaphore sem_sync;
@@ -254,4 +247,13 @@ static inline void multifd_send_prepare_header(MultiFDSendParams *p)void multifd_channel_connect (MultiFDSendParams *p,QIOChannel *ioc); +static inline uint32_t multifd_ram_page_size (void ) +{ +return qemu_target_page_size (); +} + +static inline uint32_t multifd_ram_page_count (void ) +{ +return MULTIFD_PACKET_SIZE /qemu_target_page_size (); +}#endif
Signature · 1 line
2.35.3
PATCH v5 3/18 migration/multifd: Remove pages->allocated
In reply to Fabiano RosasThis value never changes and is always the same as page_count. We don't need a copy of it per-channel plus one in the extra slot. Remove it.
--- migration/multifd.c | 6 ++---- migration/multifd.h | 2 -- 2 files changed, 2 insertions(+), 6 deletions(-)
migration/multifd.c +2 -4
@@ -396,7 +396,6 @@ static MultiFDPages_t *multifd_pages_init(uint32_t n) {MultiFDPages_t *pages =g_new0 (MultiFDPages_t,1 ); - pages->allocated = n; pages->offset =g_new0 (ram_addr_t, n);return pages;
@@ -405,7 +404,6 @@ static MultiFDPages_t *multifd_pages_init(uint32_t n)static void multifd_pages_clear (MultiFDPages_t *pages) {multifd_pages_reset (pages); - pages->allocated =0 ;g_free (pages->offset); pages->offset =NULL ;g_free (pages);
@@ -420,7 +418,7 @@ void multifd_send_fill_packet(MultiFDSendParams *p)int i; packet->flags =cpu_to_be32 (p->flags); - packet->pages_alloc =cpu_to_be32 (pages->allocated); + 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); packet->next_packet_size =cpu_to_be32 (p->next_packet_size);
@@ -651,7 +649,7 @@ static inline bool multifd_queue_empty(MultiFDPages_t *pages)static inline bool multifd_queue_full (MultiFDPages_t *pages) { -return pages->num == pages->allocated; +return pages->num ==multifd_ram_page_count (); }static inline void multifd_enqueue (MultiFDPages_t *pages,ram_addr_t offset)
migration/multifd.h +0 -2
@@ -76,8 +76,6 @@ typedef struct {uint32_t num;/* number of normal pages */ uint32_t normal_num; -/* number of allocated pages */ -uint32_t allocated;/* offset of each page */ ram_addr_t *offset;RAMBlock *block;
Signature · 1 line
2.35.3
PATCH v5 4/18 migration/multifd: Pass in MultiFDPages_t to file_write_ramblock_iov
In reply to Fabiano RosasWe want to stop dereferencing 'pages' so it can be replaced by an opaque pointer in the next patches.
--- migration/file.c | 3 ++- migration/file.h | 2 +- migration/multifd.c | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-)
migration/file.c +2 -1
@@ -196,12 +196,13 @@ void file_start_incoming_migration(FileMigrationArgs *file_args, Error **errp) }int file_write_ramblock_iov (QIOChannel *ioc,const struct iovec *iov, -int niov,RAMBlock *block,Error **errp) +int niov,MultiFDPages_t *pages,Error **errp) {ssize_t ret =0 ;int i, slice_idx, slice_num;uintptr_t base, next, offset;size_t len; +RAMBlock *block = pages->block; slice_idx =0 ; slice_num =1 ;
migration/file.h +1 -1
@@ -21,6 +21,6 @@ int file_parse_offset(char *filespec, uint64_t *offsetp, Error **errp);void file_cleanup_outgoing_migration (void );bool file_send_channel_create (gpointer opaque,Error **errp);int file_write_ramblock_iov (QIOChannel *ioc,const struct iovec *iov, -int niov,RAMBlock *block,Error **errp); +int niov,MultiFDPages_t *pages,Error **errp);int multifd_file_recv_data (MultiFDRecvParams *p,Error **errp);#endif
migration/multifd.c +1 -1
@@ -956,7 +956,7 @@ static void *multifd_send_thread(void *opaque)if (migrate_mapped_ram ()) { ret =file_write_ramblock_iov (p->c, p->iov, p->iovs_num, - pages->block, &local_err); + pages, &local_err); }else { ret = qio_channel_writev_full_all(p->c, p->iov, p->iovs_num, NULL, 0, p->write_flags,
Signature · 1 line
2.35.3
PATCH v5 5/18 migration/multifd: Introduce MultiFDSendData
In reply to Fabiano RosasAdd a new data structure to replace p->pages in the multifd channel. This new structure will hide the multifd payload type behind an union, so we don't need to add a new field to the channel each time we want to handle a different data type.
This also allow us to keep multifd_send_pages() as is, without needing to complicate the pointer switching.
--- migration/multifd.h | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+)
migration/multifd.h +26 -0
@@ -17,6 +17,7 @@#include "ram.h" typedef struct MultiFDRecvData MultiFDRecvData ; +typedef struct MultiFDSendData MultiFDSendData ;bool multifd_send_setup (void );void multifd_send_shutdown (void );
@@ -88,6 +89,31 @@ struct MultiFDRecvData {off_t file_offset; }; +typedef enum { +MULTIFD_PAYLOAD_NONE , +MULTIFD_PAYLOAD_RAM , +}MultiFDPayloadType ; + +typedef union MultiFDPayload { +MultiFDPages_t ram; +}MultiFDPayload ; + +struct MultiFDSendData { +MultiFDPayloadType type; +MultiFDPayload u; +}; + +static inline bool multifd_payload_empty (MultiFDSendData *data) +{ +return data->type ==MULTIFD_PAYLOAD_NONE ; +} + +static inline void multifd_set_payload_type (MultiFDSendData *data, +MultiFDPayloadType type) +{ + data->type = type; +} + typedef struct { /* Fields are only written at creating/deletion time */ /* No lock required for them, they are read only */
Signature · 1 line
2.35.3
PATCH v5 6/18 migration/multifd: Make MultiFDPages_t:offset a flexible array member
In reply to Fabiano RosasWe're about to use MultiFDPages_t from inside the MultiFDSendData payload union, which means we cannot have pointers to allocated data inside the pages structure, otherwise we'd lose the reference to that memory once another payload type touches the union. Move the offset array into the end of the structure and turn it into a flexible array member, so it is allocated along with the rest of MultiFDSendData in the next patches.
Note that other pointers, such as the ramblock pointer are still fine as long as the storage for them is not owned by the migration code and can be correctly released at some point.
--- migration/multifd.c | 19 ++++++++++++------- migration/multifd.h | 4 ++-- 2 files changed, 14 insertions(+), 9 deletions(-)
migration/multifd.c +12 -7
@@ -98,6 +98,17 @@ struct {MultiFDMethods *ops; } *multifd_recv_state; +static size_t multifd_ram_payload_size (void ) +{ +uint32_t n =multifd_ram_page_count (); + +/* +* We keep an array of page offsets at the end of MultiFDPages_t, +* add space for it in the allocation. +*/ +return sizeof (MultiFDPages_t) + n *sizeof (ram_addr_t); +} +static bool multifd_use_packets (void ) {return !migrate_mapped_ram ();
@@ -394,18 +405,12 @@ static int multifd_recv_initial_packet(QIOChannel *c, Error **errp)static MultiFDPages_t *multifd_pages_init (uint32_t n) { -MultiFDPages_t *pages =g_new0 (MultiFDPages_t,1 ); - - pages->offset =g_new0 (ram_addr_t, n); - -return pages; +return g_malloc0 (multifd_ram_payload_size ()); }static void multifd_pages_clear (MultiFDPages_t *pages) {multifd_pages_reset (pages); -g_free (pages->offset); - pages->offset =NULL ;g_free (pages); }
migration/multifd.h +2 -2
@@ -77,9 +77,9 @@ typedef struct {uint32_t num;/* number of normal pages */ uint32_t normal_num; +RAMBlock *block;/* offset of each page */ -ram_addr_t *offset; -RAMBlock *block; +ram_addr_t offset[]; } MultiFDPages_t;struct MultiFDRecvData {
Signature · 1 line
2.35.3
PATCH v5 7/18 migration/multifd: Replace p->pages with an union pointer
In reply to Fabiano RosasWe want multifd to be able to handle more types of data than just ram pages. To start decoupling multifd from pages, replace p->pages (MultiFDPages_t) with the new type MultiFDSendData that hides the client payload inside an union.
The general idea here is to isolate functions that *need* to handle MultiFDPages_t and move them in the future to multifd-ram.c, while multifd.c will stay with only the core functions that handle MultiFDSendData/MultiFDRecvData.
--- migration/multifd-qpl.c | 6 +-- migration/multifd-uadk.c | 2 +- migration/multifd-zero-page.c | 2 +- migration/multifd-zlib.c | 2 +- migration/multifd-zstd.c | 2 +- migration/multifd.c | 83 +++++++++++++++++++++-------------- migration/multifd.h | 7 +-- 7 files changed, 57 insertions(+), 47 deletions(-)
migration/multifd-qpl.c +3 -3
@@ -406,7 +406,7 @@ retry:static void multifd_qpl_compress_pages_slow_path (MultiFDSendParams *p) {QplData *qpl = p->compress_data; -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;uint32_t size = p->page_size;qpl_job *job = qpl->sw_job;uint8_t *zbuf = qpl->zbuf;
@@ -437,7 +437,7 @@ static void multifd_qpl_compress_pages_slow_path(MultiFDSendParams *p)static void multifd_qpl_compress_pages (MultiFDSendParams *p) {QplData *qpl = p->compress_data; -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;uint32_t size = p->page_size;QplHwJob *hw_job;uint8_t *buf;
@@ -501,7 +501,7 @@ static void multifd_qpl_compress_pages(MultiFDSendParams *p)static int multifd_qpl_send_prepare (MultiFDSendParams *p,Error **errp) {QplData *qpl = p->compress_data; -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;uint32_t len =0 ;if (!multifd_send_prepare_common (p)) {
migration/multifd-uadk.c +1 -1
@@ -177,7 +177,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)uint32_t page_size =multifd_ram_page_size ();uint8_t *buf = uadk_data->buf;int ret =0 ; -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;if (!multifd_send_prepare_common (p)) { goto out;
migration/multifd-zero-page.c +1 -1
@@ -46,7 +46,7 @@ static void swap_page_offset(ram_addr_t *pages_offset, int a, int b)*/ void multifd_send_zero_page_detect (MultiFDSendParams *p) { -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;RAMBlock *rb = pages->block;int i =0 ;int j = pages->num -1 ;
migration/multifd-zlib.c +1 -1
@@ -123,7 +123,7 @@ static void zlib_send_cleanup(MultiFDSendParams *p, Error **errp)*/ static int zlib_send_prepare (MultiFDSendParams *p,Error **errp) { -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;struct zlib_data *z = p->compress_data;z_stream *zs = &z->zs;uint32_t out_size =0 ;
migration/multifd-zstd.c +1 -1
@@ -119,7 +119,7 @@ static void zstd_send_cleanup(MultiFDSendParams *p, Error **errp)*/ static int zstd_send_prepare (MultiFDSendParams *p,Error **errp) { -MultiFDPages_t *pages = p->pages; +MultiFDPages_t *pages = &p->data->u.ram;struct zstd_data *z = p->compress_data;int ret;uint32_t i;
migration/multifd.c +49 -34
196 lines not on this page · raw message
migration/multifd.h +1 -6
@@ -152,12 +152,7 @@ typedef struct {*/ bool pending_job;bool pending_sync; -/* array of pages to sent. -* The owner of 'pages' depends of 'pending_job' value: -* pending_job == 0 -> migration_thread can use it. -* pending_job != 0 -> multifd_channel can use it. -*/ -MultiFDPages_t *pages; +MultiFDSendData *data;/* thread local variables. No locking required */
Signature · 1 line
2.35.3
PATCH v5 8/18 migration/multifd: Move pages accounting into multifd_send_zero_page_detect()
In reply to Fabiano RosasAll references to pages are being removed from the multifd worker threads in order to allow multifd to deal with different payload types.
multifd_send_zero_page_detect() is called by all multifd migration paths that deal with pages and is the last spot where zero pages and normal page amounts are adjusted. Move the pages accounting into that function.
--- migration/multifd-zero-page.c | 7 ++++++- migration/multifd.c | 2 -- 2 files changed, 6 insertions(+), 3 deletions(-)
migration/multifd-zero-page.c +6 -1
@@ -14,6 +14,7 @@#include "qemu/cutils.h" #include "exec/ramblock.h" #include "migration.h" +#include "migration-stats.h" #include "multifd.h" #include "options.h" #include "ram.h"
@@ -53,7 +54,7 @@ void multifd_send_zero_page_detect(MultiFDSendParams *p)if (!multifd_zero_page_enabled ()) { pages->normal_num = pages->num; -return ; + goto out; }/*
@@ -74,6 +75,10 @@ void multifd_send_zero_page_detect(MultiFDSendParams *p) } pages->normal_num = i; + +out: +stat64_add (&mig_stats.normal_pages, pages->normal_num); +stat64_add (&mig_stats.zero_pages, pages->num - pages->normal_num); }void multifd_recv_zero_page_process (MultiFDRecvParams *p)
migration/multifd.c +0 -2
@@ -989,8 +989,6 @@ static void *multifd_send_thread(void *opaque)stat64_add (&mig_stats.multifd_bytes, p->next_packet_size + p->packet_len); -stat64_add (&mig_stats.normal_pages, pages->normal_num); -stat64_add (&mig_stats.zero_pages, pages->num - pages->normal_num);multifd_pages_reset (pages); p->next_packet_size =0 ;
Signature · 1 line
2.35.3
PATCH v5 9/18 migration/multifd: Remove total pages tracing
In reply to Fabiano RosasThe total_normal_pages and total_zero_pages elements are used only for the end tracepoints of the multifd threads. These are not super useful since they record per-channel numbers and are just the sum of all the pages that are transmitted per-packet, for which we already have tracepoints. Remove the totals from the tracing.
--- migration/multifd.c | 12 ++---------- migration/multifd.h | 8 -------- migration/trace-events | 4 ++-- 3 files changed, 4 insertions(+), 20 deletions(-)
migration/multifd.c +2 -10
@@ -453,8 +453,6 @@ void multifd_send_fill_packet(MultiFDSendParams *p) } p->packets_sent++; - p->total_normal_pages += pages->normal_num; - p->total_zero_pages += zero_num;trace_multifd_send (p->id, packet_num, pages->normal_num, zero_num, p->flags, p->next_packet_size);
@@ -516,8 +514,6 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp) p->next_packet_size =be32_to_cpu (packet->next_packet_size); p->packet_num =be64_to_cpu (packet->packet_num); p->packets_recved++; - p->total_normal_pages += p->normal_num; - p->total_zero_pages += p->zero_num;trace_multifd_recv (p->id, p->packet_num, p->normal_num, p->zero_num, p->flags, p->next_packet_size);
@@ -1036,8 +1032,7 @@ out:rcu_unregister_thread ();migration_threads_remove (thread); -trace_multifd_send_thread_end (p->id, p->packets_sent, p->total_normal_pages, - p->total_zero_pages); +trace_multifd_send_thread_end (p->id, p->packets_sent);return NULL ; }
@@ -1561,7 +1556,6 @@ static void *multifd_recv_thread(void *opaque)qemu_sem_wait (&p->sem_sync); } }else { - p->total_normal_pages += p->data->size /qemu_target_page_size (); p->data->size =0 ;/* * Order data->size update before clearing
@@ -1578,9 +1572,7 @@ static void *multifd_recv_thread(void *opaque) }rcu_unregister_thread (); -trace_multifd_recv_thread_end (p->id, p->packets_recved, - p->total_normal_pages, - p->total_zero_pages); +trace_multifd_recv_thread_end (p->id, p->packets_recved);return NULL ; }
migration/multifd.h +0 -8
@@ -162,10 +162,6 @@ typedef struct {uint32_t next_packet_size;/* packets sent through this channel */ uint64_t packets_sent; -/* non zero pages sent through this channel */ -uint64_t total_normal_pages; -/* zero pages sent through this channel */ -uint64_t total_zero_pages;/* buffers to send */ struct iovec *iov;/* number of iovs used */
@@ -218,10 +214,6 @@ typedef struct {RAMBlock *block;/* ramblock host address */ uint8_t *host; -/* non zero pages recv through this channel */ -uint64_t total_normal_pages; -/* zero pages recv through this channel */ -uint64_t total_zero_pages;/* buffers to recv */ struct iovec *iov;/* Pages that are not zero */
migration/trace-events +2 -2
@@ -134,7 +134,7 @@ multifd_recv_sync_main(long packet_num) "packet num %ld" multifd_recv_sync_main_signal(uint8_t id) "channel %u" multifd_recv_sync_main_wait(uint8_t id) "iter %u" multifd_recv_terminate_threads(bool error) "error %d" -multifd_recv_thread_end(uint8_t id, uint64_t packets, uint64_t normal_pages, uint64_t zero_pages) "channel %u packets %" PRIu64 " normal pages %" PRIu64 " zero pages %" PRIu64 +multifd_recv_thread_end(uint8_t id, uint64_t packets) "channel %u packets %" PRIu64 multifd_recv_thread_start(uint8_t id) "%u" multifd_send(uint8_t id, uint64_t packet_num, uint32_t normal_pages, uint32_t zero_pages, uint32_t flags, uint32_t next_packet_size) "channel %u packet_num %" PRIu64 " normal pages %u zero pages %u flags 0x%x next packet size %u" multifd_send_error(uint8_t id) "channel %u"
@@ -142,7 +142,7 @@ multifd_send_sync_main(long packet_num) "packet num %ld" multifd_send_sync_main_signal(uint8_t id) "channel %u" multifd_send_sync_main_wait(uint8_t id) "channel %u" multifd_send_terminate_threads(void) "" -multifd_send_thread_end(uint8_t id, uint64_t packets, uint64_t normal_pages, uint64_t zero_pages) "channel %u packets %" PRIu64 " normal pages %" PRIu64 " zero pages %" PRIu64 +multifd_send_thread_end(uint8_t id, uint64_t packets) "channel %u packets %" PRIu64 multifd_send_thread_start(uint8_t id) "%u" multifd_tls_outgoing_handshake_start(void *ioc, void *tioc, const char *hostname) "ioc=%p tioc=%p hostname=%s" multifd_tls_outgoing_handshake_error(void *ioc, const char *err) "ioc=%p err=%s"
Signature · 1 line
2.35.3
PATCH v5 10/18 migration/multifd: Isolate ram pages packet data
In reply to Fabiano RosasWhile we cannot yet disentangle the multifd packet from page data, we can make the code a bit cleaner by setting the page-related fields in a separate function.
--- migration/multifd.c | 99 +++++++++++++++++++++++++----------------- migration/trace-events | 5 ++- 2 files changed, 63 insertions(+), 41 deletions(-)
migration/multifd.c +60 -39
@@ -424,65 +424,61 @@ static int multifd_recv_initial_packet(QIOChannel *c, Error **errp)return msg.id; } -void multifd_send_fill_packet (MultiFDSendParams *p) +static void multifd_ram_fill_packet (MultiFDSendParams *p) {MultiFDPacket_t *packet = p->packet;MultiFDPages_t *pages = &p->data->u.ram; -uint64_t packet_num;uint32_t zero_num = pages->num - pages->normal_num; -int i; - packet->flags =cpu_to_be32 (p->flags); 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); - packet->next_packet_size =cpu_to_be32 (p->next_packet_size); - - packet_num =qatomic_fetch_inc (&multifd_send_state->packet_num); - packet->packet_num =cpu_to_be64 (packet_num);if (pages->block) {strncpy (packet->ramblock, pages->block->idstr,256 ); } -for (i =0 ; i < pages->num; i++) { +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); +} + +void multifd_send_fill_packet (MultiFDSendParams *p) +{ +MultiFDPacket_t *packet = p->packet; +uint64_t packet_num; + +memset (packet,0 , p->packet_len); + + packet->magic =cpu_to_be32 (MULTIFD_MAGIC ); + packet->version =cpu_to_be32 (MULTIFD_VERSION ); + + packet->flags =cpu_to_be32 (p->flags); + packet->next_packet_size =cpu_to_be32 (p->next_packet_size); + + packet_num =qatomic_fetch_inc (&multifd_send_state->packet_num); + packet->packet_num =cpu_to_be64 (packet_num); + p->packets_sent++; -trace_multifd_send (p->id, packet_num, pages->normal_num, zero_num, - p->flags, p->next_packet_size); +multifd_ram_fill_packet (p); + +trace_multifd_send_fill (p->id, packet_num, + p->flags, p->next_packet_size); } -static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) +static 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 ();int i; - packet->magic =be32_to_cpu (packet->magic); -if (packet->magic !=MULTIFD_MAGIC ) { -error_setg (errp,"multifd: received packet " -"magic %x and expected magic %x" , - packet->magic,MULTIFD_MAGIC ); -return -1 ; - } - - packet->version =be32_to_cpu (packet->version); -if (packet->version !=MULTIFD_VERSION ) { -error_setg (errp,"multifd: received packet " -"version %u and expected version %u" , - packet->version,MULTIFD_VERSION ); -return -1 ; - } - - p->flags =be32_to_cpu (packet->flags); - packet->pages_alloc =be32_to_cpu (packet->pages_alloc);/* * If we received a packet that is 100 times bigger than expected
@@ -511,13 +507,6 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)return -1 ; } - p->next_packet_size =be32_to_cpu (packet->next_packet_size); - p->packet_num =be64_to_cpu (packet->packet_num); - p->packets_recved++; - -trace_multifd_recv (p->id, p->packet_num, p->normal_num, p->zero_num, - p->flags, p->next_packet_size); -if (p->normal_num ==0 && p->zero_num ==0 ) {return 0 ; }
@@ -559,6 +548,40 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)return 0 ; } +static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) +{ +MultiFDPacket_t *packet = p->packet; +int ret =0 ; + + packet->magic =be32_to_cpu (packet->magic); +if (packet->magic !=MULTIFD_MAGIC ) { +error_setg (errp,"multifd: received packet " +"magic %x and expected magic %x" , + packet->magic,MULTIFD_MAGIC ); +return -1 ; + } + + packet->version =be32_to_cpu (packet->version); +if (packet->version !=MULTIFD_VERSION ) { +error_setg (errp,"multifd: received packet " +"version %u and expected version %u" , + packet->version,MULTIFD_VERSION ); +return -1 ; + } + + p->flags =be32_to_cpu (packet->flags); + p->next_packet_size =be32_to_cpu (packet->next_packet_size); + p->packet_num =be64_to_cpu (packet->packet_num); + p->packets_recved++; + + ret =multifd_ram_unfill_packet (p, errp); + +trace_multifd_recv_unfill (p->id, p->packet_num, p->flags, + p->next_packet_size); + +return ret; +} +static bool multifd_send_should_exit (void ) {return qatomic_read (&multifd_send_state->exiting);
@@ -1203,8 +1226,6 @@ bool multifd_send_setup(void) p->packet_len =sizeof (MultiFDPacket_t) +sizeof (uint64_t ) * page_count; p->packet =g_malloc0 (p->packet_len); - p->packet->magic =cpu_to_be32 (MULTIFD_MAGIC ); - p->packet->version =cpu_to_be32 (MULTIFD_VERSION ); } p->name =g_strdup_printf ("mig/src/send_%d" , i); p->write_flags =0 ;
migration/trace-events +3 -2
@@ -128,7 +128,7 @@ postcopy_preempt_reset_channel(void) "" # multifd.c multifd_new_send_channel_async(uint8_t id) "channel %u" multifd_new_send_channel_async_error(uint8_t id, void *err) "channel=%u err=%p" -multifd_recv(uint8_t id, uint64_t packet_num, uint32_t normal, uint32_t zero, uint32_t flags, uint32_t next_packet_size) "channel %u packet_num %" PRIu64 " normal pages %u zero pages %u flags 0x%x next packet size %u" +multifd_recv_unfill(uint8_t id, uint64_t packet_num, uint32_t flags, uint32_t next_packet_size) "channel %u packet_num %" PRIu64 " flags 0x%x next packet size %u" multifd_recv_new_channel(uint8_t id) "channel %u" multifd_recv_sync_main(long packet_num) "packet num %ld" multifd_recv_sync_main_signal(uint8_t id) "channel %u"
@@ -136,7 +136,8 @@ multifd_recv_sync_main_wait(uint8_t id) "iter %u" multifd_recv_terminate_threads(bool error) "error %d" multifd_recv_thread_end(uint8_t id, uint64_t packets) "channel %u packets %" PRIu64 multifd_recv_thread_start(uint8_t id) "%u" -multifd_send(uint8_t id, uint64_t packet_num, uint32_t normal_pages, uint32_t zero_pages, uint32_t flags, uint32_t next_packet_size) "channel %u packet_num %" PRIu64 " normal pages %u zero pages %u flags 0x%x next packet size %u" +multifd_send_fill(uint8_t id, uint64_t packet_num, uint32_t flags, uint32_t next_packet_size) "channel %u packet_num %" PRIu64 " flags 0x%x next packet size %u" +multifd_send_ram_fill(uint8_t id, uint32_t normal, uint32_t zero) "channel %u normal pages %u zero pages %u" multifd_send_error(uint8_t id) "channel %u" multifd_send_sync_main(long packet_num) "packet num %ld" multifd_send_sync_main_signal(uint8_t id) "channel %u"
Signature · 1 line
2.35.3
PATCH v5 11/18 migration/multifd: Don't send ram data during SYNC
In reply to Fabiano RosasSkip saving and loading any ram data in the packet in the case of a SYNC. This fixes a shortcoming of the current code which requires a reset of the MultiFDPages_t fields right after the previous pending_job finishes, otherwise the very next job might be a SYNC and multifd_send_fill_packet() will put the stale values in the packet.
By not calling multifd_ram_fill_packet(), we can stop resetting MultiFDPages_t in the multifd core and leave that to the client code.
Actually moving the reset function is not yet done because pages->num==0 is used by the client code to determine whether the MultiFDPages_t needs to be flushed. The subsequent patches will replace that with a generic flag that is not dependent on MultiFDPages_t.
--- migration/multifd.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
migration/multifd.c +10 -3
@@ -452,6 +452,7 @@ void multifd_send_fill_packet(MultiFDSendParams *p) {MultiFDPacket_t *packet = p->packet;uint64_t packet_num; +bool sync_packet = p->flags &MULTIFD_FLAG_SYNC ;memset (packet,0 , p->packet_len);
@@ -466,7 +467,9 @@ void multifd_send_fill_packet(MultiFDSendParams *p) p->packets_sent++; -multifd_ram_fill_packet (p); +if (!sync_packet) { +multifd_ram_fill_packet (p); + }trace_multifd_send_fill (p->id, packet_num, p->flags, p->next_packet_size);
@@ -574,7 +577,9 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp) p->packet_num =be64_to_cpu (packet->packet_num); p->packets_recved++; - ret =multifd_ram_unfill_packet (p, errp); +if (!(p->flags &MULTIFD_FLAG_SYNC )) { + ret =multifd_ram_unfill_packet (p, errp); + }trace_multifd_recv_unfill (p->id, p->packet_num, p->flags, p->next_packet_size);
@@ -1536,7 +1541,9 @@ static void *multifd_recv_thread(void *opaque) flags = p->flags;/* recv methods don't know how to handle the SYNC flag */ p->flags &= ~MULTIFD_FLAG_SYNC ; - has_data = p->normal_num || p->zero_num; +if (!(flags &MULTIFD_FLAG_SYNC )) { + has_data = p->normal_num || p->zero_num; + }qemu_mutex_unlock (&p->mutex); }else {/*
Signature · 1 line
2.35.3
PATCH v5 12/18 migration/multifd: Replace multifd_send_state->pages with client data
In reply to Fabiano RosasMultifd currently has a simple scheduling mechanism that distributes work to the various channels by keeping storage space within each channel and an extra space that is given to the client. Each time the client fills the space with data and calls into multifd, that space is given to the next idle channel and a free storage space is taken from the channel and given to client for the next iteration.
This means we always need (#multifd_channels + 1) memory slots to operate multifd.
This is fine, except that the presence of this one extra memory slot doesn't allow different types of payloads to be processed at the same time in different channels, i.e. the data type of multifd_send_state->pages needs to be the same as p->pages.
For each new data type different from MultiFDPage_t that is to be handled, this logic would need to be duplicated by adding new fields to multifd_send_state, to the channels and to multifd_send_pages().
Fix this situation by moving the extra slot into the client and using only the generic type MultiFDSendData in the multifd core.
--- migration/multifd.c | 79 ++++++++++++++++++++++++++------------------- migration/multifd.h | 3 ++ migration/ram.c | 2 ++ 3 files changed, 50 insertions(+), 34 deletions(-)
migration/multifd.c +45 -34
@@ -49,7 +49,6 @@ typedef struct {struct {MultiFDSendParams *params; -MultiFDSendData *data;/* * Global number of generated multifd packets. *
@@ -97,6 +96,8 @@ struct {MultiFDMethods *ops; } *multifd_recv_state; +static MultiFDSendData *multifd_ram_send; +static size_t multifd_ram_payload_size (void ) {uint32_t n =multifd_ram_page_count ();
@@ -130,6 +131,17 @@ static MultiFDSendData *multifd_send_data_alloc(void)return g_malloc0 (size_minus_payload + max_payload_size); } +void multifd_ram_save_setup (void ) +{ + multifd_ram_send =multifd_send_data_alloc (); +} + +void multifd_ram_save_cleanup (void ) +{ +g_free (multifd_ram_send); + multifd_ram_send =NULL ; +} +static bool multifd_use_packets (void ) {return !migrate_mapped_ram ();
@@ -610,25 +622,20 @@ static void multifd_send_kick_main(MultiFDSendParams *p) }/* -* How we use multifd_send_state->pages and channel->pages? +* multifd_send() works by exchanging the MultiFDSendData object +* provided by the caller with an unused MultiFDSendData object from +* the next channel that is found to be idle. * -* We create a pages for each channel, and a main one. Each time that -* we need to send a batch of pages we interchange the ones between -* multifd_send_state and the channel that is sending it. There are -* two reasons for that: -* - to not have to do so many mallocs during migration -* - to make easier to know what to free at the end of migration +* The channel owns the data until it finishes transmitting and the +* caller owns the empty object until it fills it with data and calls +* this function again. No locking necessary. * -* This way we always know who is the owner of each "pages" struct, -* and we don't need any locking. It belongs to the migration thread -* or to the channel thread. Switching is safe because the migration -* thread is using the channel mutex when changing it, and the channel -* have to had finish with its own, otherwise pending_job can't be -* false. +* Switching is safe because both the migration thread and the channel +* thread have barriers in place to serialize access. * * Returns true if succeed, false otherwise. */ -static bool multifd_send_pages (void ) +static bool multifd_send (MultiFDSendData **send_data) {int i;static int next_channel;
@@ -669,11 +676,16 @@ static bool multifd_send_pages(void)*/ smp_mb_acquire (); -assert (!p->data->u.ram.num); +assert (multifd_payload_empty (p->data)); - tmp = multifd_send_state->data; - multifd_send_state->data = p->data; +/* +* Swap the pointers. The channel gets the client data for +* transferring and the client gets back an unused data slot. +*/ + tmp = *send_data; + *send_data = p->data; p->data = tmp; +/* * Making sure p->data is setup before marking pending_job=true. Pairs * with the qatomic_load_acquire() in multifd_send_thread().
@@ -705,7 +717,12 @@ bool multifd_queue_page(RAMBlock *block, ram_addr_t offset)MultiFDPages_t *pages; retry: - pages = &multifd_send_state->data->u.ram; + 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)) {
@@ -723,7 +740,7 @@ retry:* After flush, always retry. */ if (pages->block != block ||multifd_queue_full (pages)) { -if (!multifd_send_pages ()) { +if (!multifd_send (&multifd_ram_send)) {return false; } goto retry;
@@ -853,8 +870,6 @@ static void multifd_send_cleanup_state(void)qemu_sem_destroy (&multifd_send_state->channels_ready);g_free (multifd_send_state->params); multifd_send_state->params =NULL ; -g_free (multifd_send_state->data); - multifd_send_state->data =NULL ;g_free (multifd_send_state); multifd_send_state =NULL ; }
@@ -903,15 +918,14 @@ int multifd_send_sync_main(void) {int i;bool flush_zero_copy; -MultiFDPages_t *pages;if (!migrate_multifd ()) {return 0 ; } - pages = &multifd_send_state->data->u.ram; -if (pages->num) { -if (!multifd_send_pages ()) { -error_report ("%s: multifd_send_pages fail" , __func__); + +if (!multifd_payload_empty (multifd_ram_send)) { +if (!multifd_send (&multifd_ram_send)) { +error_report ("%s: multifd_send fail" , __func__);return -1 ; } }
@@ -985,13 +999,11 @@ static void *multifd_send_thread(void *opaque)/* * Read pending_job flag before p->data. Pairs with the -* qatomic_store_release() in multifd_send_pages(). +* qatomic_store_release() in multifd_send(). */ if (qatomic_load_acquire (&p->pending_job)) { -MultiFDPages_t *pages = &p->data->u.ram; - p->iovs_num =0 ; -assert (pages->num); +assert (!multifd_payload_empty (p->data)); ret = multifd_send_state->ops->send_prepare (p, &local_err);if (ret !=0 ) {
@@ -1014,13 +1026,13 @@ static void *multifd_send_thread(void *opaque)stat64_add (&mig_stats.multifd_bytes, p->next_packet_size + p->packet_len); -multifd_pages_reset (pages); p->next_packet_size =0 ; +multifd_set_payload_type (p->data,MULTIFD_PAYLOAD_NONE );/* * Making sure p->data is published before saying "we're * free". Pairs with the smp_mb_acquire() in -* multifd_send_pages(). +* multifd_send(). */ qatomic_store_release (&p->pending_job, false); }else {
@@ -1212,7 +1224,6 @@ bool multifd_send_setup(void) thread_count =migrate_multifd_channels (); multifd_send_state =g_malloc0 (sizeof (*multifd_send_state)); multifd_send_state->params =g_new0 (MultiFDSendParams, thread_count); - multifd_send_state->data =multifd_send_data_alloc ();qemu_sem_init (&multifd_send_state->channels_created,0 );qemu_sem_init (&multifd_send_state->channels_ready,0 );qatomic_set (&multifd_send_state->exiting,0 );
migration/multifd.h +3 -0
@@ -267,4 +267,7 @@ static inline uint32_t multifd_ram_page_count(void) {return MULTIFD_PACKET_SIZE /qemu_target_page_size (); } + +void multifd_ram_save_setup (void ); +void multifd_ram_save_cleanup (void );#endif
migration/ram.c +2 -0
@@ -2387,6 +2387,7 @@ static void ram_save_cleanup(void *opaque)ram_bitmaps_destroy ();xbzrle_cleanup (); +multifd_ram_save_cleanup ();ram_state_cleanup (rsp);g_free (migration_ops); migration_ops =NULL ;
@@ -3058,6 +3059,7 @@ static int ram_save_setup(QEMUFile *f, void *opaque, Error **errp) migration_ops =g_malloc0 (sizeof (MigrationOps));if (migrate_multifd ()) { +multifd_ram_save_setup (); migration_ops->ram_save_target_page = ram_save_target_page_multifd; }else { migration_ops->ram_save_target_page = ram_save_target_page_legacy;
Signature · 1 line
2.35.3
PATCH v5 13/18 migration/multifd: Allow multifd sync without flush
In reply to Fabiano RosasSeparate the multifd sync from flushing the client data to the channels. These two operations are closely related but not strictly necessary to be executed together.
The multifd sync is intrinsic to how multifd works. The multiple channels operate independently and may finish IO out of order in relation to each other. This applies also between the source and destination QEMU.
Flushing the data that is left in the client-owned data structures (e.g. MultiFDPages_t) prior to sync is usually the right thing to do, but that is particular to how the ram migration is implemented with several passes over dirty data.
Make these two routines separate, allowing future code to call the sync by itself if needed. This also allows the usage of multifd_ram_send to be isolated to ram code.
--- migration/multifd.c | 13 +++++++++---- migration/multifd.h | 1 + migration/ram.c | 8 ++++---- 3 files changed, 14 insertions(+), 8 deletions(-)
migration/multifd.c +9 -4
@@ -914,11 +914,8 @@ static int multifd_zero_copy_flush(QIOChannel *c)return ret; } -int multifd_send_sync_main (void ) +int multifd_ram_flush_and_sync (void ) { -int i; -bool flush_zero_copy; -if (!migrate_multifd ()) {return 0 ; }
@@ -930,6 +927,14 @@ int multifd_send_sync_main(void) } } +return multifd_send_sync_main (); +} + +int multifd_send_sync_main (void ) +{ +int i; +bool flush_zero_copy; + flush_zero_copy =migrate_zero_copy_send ();for (i =0 ; i <migrate_multifd_channels (); i++) {
migration/multifd.h +1 -0
@@ -270,4 +270,5 @@ static inline uint32_t multifd_ram_page_count(void)void multifd_ram_save_setup (void );void multifd_ram_save_cleanup (void ); +int multifd_ram_flush_and_sync (void );#endif
migration/ram.c +4 -4
@@ -1326,7 +1326,7 @@ static int find_dirty_block(RAMState *rs, PageSearchStatus *pss) (!migrate_multifd_flush_after_each_section() || migrate_mapped_ram())) {QEMUFile *f = rs->pss[RAM_CHANNEL_PRECOPY ].pss_channel; -int ret =multifd_send_sync_main (); +int ret =multifd_ram_flush_and_sync ();if (ret <0 ) {return ret; }
@@ -3066,7 +3066,7 @@ static int ram_save_setup(QEMUFile *f, void *opaque, Error **errp) }bql_unlock (); - ret =multifd_send_sync_main (); + ret =multifd_ram_flush_and_sync ();bql_lock ();if (ret <0 ) {error_setg (errp,"%s: multifd synchronization failed" , __func__);
@@ -3213,7 +3213,7 @@ out: && migration_is_setup_or_active()) {if (migrate_multifd () &&migrate_multifd_flush_after_each_section () && !migrate_mapped_ram ()) { - ret =multifd_send_sync_main (); + ret =multifd_ram_flush_and_sync ();if (ret <0 ) {return ret; }
@@ -3285,7 +3285,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque) } } - ret =multifd_send_sync_main (); + ret =multifd_ram_flush_and_sync ();if (ret <0 ) {return ret; }
Signature · 1 line
2.35.3
PATCH v5 14/18 migration/multifd: Standardize on multifd ops names
In reply to Fabiano RosasAdd the multifd_ prefix to all functions and remove the useless docstrings.
--- migration/multifd-qpl.c | 57 ---------------------------- migration/multifd-uadk.c | 55 --------------------------- migration/multifd-zlib.c | 81 ++++++---------------------------------- migration/multifd-zstd.c | 81 ++++++---------------------------------- migration/multifd.c | 78 ++++++-------------------------------- 5 files changed, 36 insertions(+), 316 deletions(-)
migration/multifd-qpl.c +0 -57
@@ -220,16 +220,6 @@ static void multifd_qpl_deinit(QplData *qpl) } } -/** -* multifd_qpl_send_setup: set up send side -* -* Set up the channel with QPL compression. -* -* Returns 0 on success or -1 on error -* -* @p: Params for the channel being used -* @errp: pointer to an error -*/ static int multifd_qpl_send_setup (MultiFDSendParams *p,Error **errp) {QplData *qpl;
@@ -251,14 +241,6 @@ static int multifd_qpl_send_setup(MultiFDSendParams *p, Error **errp)return 0 ; } -/** -* multifd_qpl_send_cleanup: clean up send side -* -* Close the channel and free memory. -* -* @p: Params for the channel being used -* @errp: pointer to an error -*/ static void multifd_qpl_send_cleanup (MultiFDSendParams *p,Error **errp) {multifd_qpl_deinit (p->compress_data);
@@ -487,17 +469,6 @@ static void multifd_qpl_compress_pages(MultiFDSendParams *p) } } -/** -* multifd_qpl_send_prepare: prepare data to be able to send -* -* Create a compressed buffer with all the pages that we are going to -* send. -* -* Returns 0 on success or -1 on error -* -* @p: Params for the channel being used -* @errp: pointer to an error -*/ static int multifd_qpl_send_prepare (MultiFDSendParams *p,Error **errp) {QplData *qpl = p->compress_data;
@@ -523,16 +494,6 @@ out:return 0 ; } -/** -* multifd_qpl_recv_setup: set up receive side -* -* Create the compressed channel and buffer. -* -* Returns 0 on success or -1 on error -* -* @p: Params for the channel being used -* @errp: pointer to an error -*/ static int multifd_qpl_recv_setup (MultiFDRecvParams *p,Error **errp) {QplData *qpl;
@@ -547,13 +508,6 @@ static int multifd_qpl_recv_setup(MultiFDRecvParams *p, Error **errp)return 0 ; } -/** -* multifd_qpl_recv_cleanup: set up receive side -* -* Close the channel and free memory. -* -* @p: Params for the channel being used -*/ static void multifd_qpl_recv_cleanup (MultiFDRecvParams *p) {multifd_qpl_deinit (p->compress_data);
@@ -694,17 +648,6 @@ static int multifd_qpl_decompress_pages(MultiFDRecvParams *p, Error **errp) }return 0 ; } -/** -* multifd_qpl_recv: read the data from the channel into actual pages -* -* Read the compressed buffer, and uncompress it into the actual -* pages. -* -* Returns 0 on success or -1 on error -* -* @p: Params for the channel being used -* @errp: pointer to an error -*/ static int multifd_qpl_recv (MultiFDRecvParams *p,Error **errp) {QplData *qpl = p->compress_data;
migration/multifd-uadk.c +0 -55
91 lines not on this page · raw message
migration/multifd-zlib.c +12 -69
123 lines not on this page · raw message
migration/multifd-zstd.c +12 -69
123 lines not on this page · raw message
migration/multifd.c +12 -66
118 lines not on this page · raw message
Signature · 1 line
2.35.3
PATCH v5 15/18 migration/multifd: Register nocomp ops dynamically
In reply to Fabiano RosasPrior to moving the ram code into multifd-nocomp.c, change the code to register the nocomp ops dynamically so we don't need to have the ops structure defined in multifd.c.
While here, move the ops struct initialization to the end of the file to make the next diff cleaner.
--- migration/multifd.c | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-)
migration/multifd.c +19 -13
@@ -287,22 +287,12 @@ static int multifd_nocomp_recv(MultiFDRecvParams *p, Error **errp)return qio_channel_readv_all (p->c, p->iov, p->normal_num, errp); } -static 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 MultiFDMethods *multifd_ops[MULTIFD_COMPRESSION__MAX ] = { - [MULTIFD_COMPRESSION_NONE ] = &multifd_nocomp_ops, -}; +static MultiFDMethods *multifd_ops[MULTIFD_COMPRESSION__MAX ] = {};void multifd_register_ops (int method,MultiFDMethods *ops) { -assert (0 < method && method <MULTIFD_COMPRESSION__MAX ); +assert (0 <= method && method <MULTIFD_COMPRESSION__MAX ); +assert (!multifd_ops[method]); multifd_ops[method] = ops; }
@@ -1701,3 +1691,19 @@ bool multifd_send_prepare_common(MultiFDSendParams *p)return true; } + +static 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);
Signature · 1 line
2.35.3
PATCH v5 16/18 migration/multifd: Move nocomp code into multifd-nocomp.c
In reply to Fabiano RosasIn preparation for adding new payload types to multifd, move most of the no-compression code into multifd-nocomp.c. Let's try to keep a semblance of layering by not mixing general multifd control flow with the details of transmitting pages of ram.
There are still some pieces leftover, namely the p->normal, p->zero, etc variables that we use for zero page tracking and the packet allocation which is heavily dependent on the ram code.
--- migration/meson.build | 1 + migration/multifd-nocomp.c | 394 +++++++++++++++++++++++++++++++++++++ migration/multifd.c | 377 +---------------------------------- migration/multifd.h | 5 + 4 files changed, 402 insertions(+), 375 deletions(-) create mode 100644 migration/multifd-nocomp.c
migration/meson.build +1 -0
@@ -21,6 +21,7 @@ system_ss.add(files( 'migration-hmp-cmds.c', 'migration.c', 'multifd.c', + 'multifd-nocomp.c', 'multifd-zlib.c', 'multifd-zero-page.c', 'options.c',
migration/multifd-nocomp.c new file +394 -0
394 lines not on this page · raw message
migration/multifd.c +2 -375
434 lines not on this page · raw message
migration/multifd.h +5 -0
@@ -257,6 +257,8 @@ static inline void multifd_send_prepare_header(MultiFDSendParams *p) }void multifd_channel_connect (MultiFDSendParams *p,QIOChannel *ioc); +bool multifd_send (MultiFDSendData **send_data); +MultiFDSendData *multifd_send_data_alloc (void );static inline uint32_t multifd_ram_page_size (void ) {
@@ -271,4 +273,7 @@ static inline uint32_t multifd_ram_page_count(void)void multifd_ram_save_setup (void );void multifd_ram_save_cleanup (void );int multifd_ram_flush_and_sync (void ); +size_t multifd_ram_payload_size (void ); +void multifd_ram_fill_packet (MultiFDSendParams *p); +int multifd_ram_unfill_packet (MultiFDRecvParams *p,Error **errp);#endif
Signature · 1 line
2.35.3
PATCH v5 17/18 migration/multifd: Make MultiFDMethods const
In reply to Fabiano RosasThe methods are defined at module_init time and don't ever change. Make them const.
--- migration/multifd-nocomp.c | 2 +- migration/multifd-qpl.c | 2 +- migration/multifd-uadk.c | 2 +- migration/multifd-zlib.c | 2 +- migration/multifd-zstd.c | 2 +- migration/multifd.c | 8 ++++---- migration/multifd.h | 2 +- 7 files changed, 10 insertions(+), 10 deletions(-)
migration/multifd-nocomp.c +1 -1
@@ -377,7 +377,7 @@ bool multifd_send_prepare_common(MultiFDSendParams *p)return true; } -static MultiFDMethods multifd_nocomp_ops = { +static const MultiFDMethods multifd_nocomp_ops = { .send_setup = multifd_nocomp_send_setup, .send_cleanup = multifd_nocomp_send_cleanup, .send_prepare = multifd_nocomp_send_prepare,
migration/multifd-qpl.c +1 -1
@@ -694,7 +694,7 @@ static int multifd_qpl_recv(MultiFDRecvParams *p, Error **errp)return multifd_qpl_decompress_pages_slow_path (p, errp); } -static MultiFDMethods multifd_qpl_ops = { +static const MultiFDMethods multifd_qpl_ops = { .send_setup = multifd_qpl_send_setup, .send_cleanup = multifd_qpl_send_cleanup, .send_prepare = multifd_qpl_send_prepare,
migration/multifd-uadk.c +1 -1
@@ -305,7 +305,7 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp)return 0 ; } -static MultiFDMethods multifd_uadk_ops = { +static const MultiFDMethods multifd_uadk_ops = { .send_setup = multifd_uadk_send_setup, .send_cleanup = multifd_uadk_send_cleanup, .send_prepare = multifd_uadk_send_prepare,
migration/multifd-zlib.c +1 -1
@@ -277,7 +277,7 @@ static int multifd_zlib_recv(MultiFDRecvParams *p, Error **errp)return 0 ; } -static MultiFDMethods multifd_zlib_ops = { +static const MultiFDMethods multifd_zlib_ops = { .send_setup = multifd_zlib_send_setup, .send_cleanup = multifd_zlib_send_cleanup, .send_prepare = multifd_zlib_send_prepare,
migration/multifd-zstd.c +1 -1
@@ -265,7 +265,7 @@ static int multifd_zstd_recv(MultiFDRecvParams *p, Error **errp)return 0 ; } -static MultiFDMethods multifd_zstd_ops = { +static const MultiFDMethods multifd_zstd_ops = { .send_setup = multifd_zstd_send_setup, .send_cleanup = multifd_zstd_send_cleanup, .send_prepare = multifd_zstd_send_prepare,
migration/multifd.c +4 -4
@@ -76,7 +76,7 @@ struct {*/ int exiting;/* multifd ops */ -MultiFDMethods *ops; +const MultiFDMethods *ops; } *multifd_send_state;struct {
@@ -93,7 +93,7 @@ struct {uint64_t packet_num;int exiting;/* multifd ops */ -MultiFDMethods *ops; +const MultiFDMethods *ops; } *multifd_recv_state;MultiFDSendData *multifd_send_data_alloc (void )
@@ -128,9 +128,9 @@ void multifd_send_channel_created(void)qemu_sem_post (&multifd_send_state->channels_created); } -static MultiFDMethods *multifd_ops[MULTIFD_COMPRESSION__MAX ] = {}; +static const MultiFDMethods *multifd_ops[MULTIFD_COMPRESSION__MAX ] = {}; -void multifd_register_ops (int method,MultiFDMethods *ops) +void multifd_register_ops (int method,const MultiFDMethods *ops) {assert (0 <= method && method <MULTIFD_COMPRESSION__MAX );assert (!multifd_ops[method]);
migration/multifd.h +1 -1
@@ -243,7 +243,7 @@ typedef struct {int (*recv)(MultiFDRecvParams *p,Error **errp); } MultiFDMethods; -void multifd_register_ops (int method,MultiFDMethods *ops); +void multifd_register_ops (int method,const MultiFDMethods *ops);void multifd_send_fill_packet (MultiFDSendParams *p);bool multifd_send_prepare_common (MultiFDSendParams *p);void multifd_send_zero_page_detect (MultiFDSendParams *p);
Signature · 1 line
2.35.3
Re: [PATCH v5 17/18] migration/multifd: Make MultiFDMethods const
Quoted 5 lines · Fabiano Rosas
The methods are defined at
module_inittime and don't ever change. Make them const.Suggested-by Philippe Mathieu-Daudé <[email protected]>Signed-off-by Fabiano Rosas <[email protected]>
Signature · 1 line
Peter Xu
PATCH v5 18/18 migration/multifd: Stop changing the packet on recv side
In reply to Fabiano RosasAs observed by Philippe, the multifd_ram_unfill_packet() function currently leaves the MultiFDPacket structure with mixed endianness. This is harmless, but ultimately not very clean. Aside from that, the packet is also written to on the recv side to ensure the ramblock name is null-terminated.
Stop touching the received packet and do the necessary work using stack variables instead.
While here tweak the error strings and fix the space before semicolons. Also remove the "100 times bigger" comment because it's just one possible explanation for a size mismatch and it doesn't even match the code.
--- migration/multifd-nocomp.c | 38 ++++++++++++++++---------------------- migration/multifd.c | 18 ++++++++---------- 2 files changed, 24 insertions(+), 32 deletions(-)
migration/multifd-nocomp.c +16 -22
@@ -220,33 +220,29 @@ 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); +const char *ramblock_name;int i; - packet->pages_alloc =be32_to_cpu (packet->pages_alloc); -/* -* If we received a packet that is 100 times bigger than expected -* just stop migration. It is a magic number. -*/ -if (packet->pages_alloc > page_count) { -error_setg (errp,"multifd: received packet " -"with size %u and expected a size of %u" , - packet->pages_alloc, page_count) ; +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 > packet->pages_alloc) { -error_setg (errp,"multifd: received packet " -"with %u normal pages and expected maximum pages are %u" , - p->normal_num, packet->pages_alloc) ; +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 > packet->pages_alloc - p->normal_num) { -error_setg (errp,"multifd: received packet " -"with %u zero pages and expected maximum zero pages are %u" , - p->zero_num, packet->pages_alloc - p->normal_num) ; +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 ; }
@@ -254,12 +250,10 @@ int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp)return 0 ; } -/* make sure that ramblock is 0 terminated */ - packet->ramblock[255 ] =0 ; - p->block =qemu_ram_block_by_name (packet->ramblock); + ramblock_name =g_strndup (packet->ramblock,255 ); + p->block =qemu_ram_block_by_name (ramblock_name);if (!p->block) { -error_setg (errp,"multifd: unknown ram block %s" , - packet->ramblock); +error_setg (errp,"multifd: unknown ram block %s" , ramblock_name);return -1 ; }
migration/multifd.c +8 -10
@@ -231,21 +231,19 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; +uint32_t magic =be32_to_cpu (packet->magic); +uint32_t version =be32_to_cpu (packet->version);int ret =0 ; - packet->magic =be32_to_cpu (packet->magic); -if (packet->magic !=MULTIFD_MAGIC ) { -error_setg (errp,"multifd: received packet " -"magic %x and expected magic %x" , - packet->magic,MULTIFD_MAGIC ); +if (magic !=MULTIFD_MAGIC ) { +error_setg (errp,"multifd: received packet magic %x, expected %x" , + magic,MULTIFD_MAGIC );return -1 ; } - packet->version =be32_to_cpu (packet->version); -if (packet->version !=MULTIFD_VERSION ) { -error_setg (errp,"multifd: received packet " -"version %u and expected version %u" , - packet->version,MULTIFD_VERSION ); +if (version !=MULTIFD_VERSION ) { +error_setg (errp,"multifd: received packet version %u, expected %u" , + version,MULTIFD_VERSION );return -1 ; }
Signature · 1 line
2.35.3
Re: [PATCH v5 18/18] migration/multifd: Stop changing the packet on recv side
Quoted 73 lines · Fabiano Rosas
As observed by Philippe, the
multifd_ram_unfill_packet()function currently leaves the MultiFDPacket structure with mixed endianness. This is harmless, but ultimately not very clean. Aside from that, the packet is also written to on the recv side to ensure the ramblock name is null-terminated.Stop touching the received packet and do the necessary work using stack variables instead.
While here tweak the error strings and fix the space before semicolons. Also remove the "100 times bigger" comment because it's just one possible explanation for a size mismatch and it doesn't even match the code.
CC Philippe Mathieu-Daudé <[email protected]>Signed-off-by Fabiano Rosas <[email protected]>--- migration/multifd-nocomp.c | 38 ++++++++++++++++---------------------- migration/multifd.c | 18 ++++++++---------- 2 files changed, 24 insertions(+), 32 deletions(-)migration/multifd-nocomp.c +13
-17@@ -220,33 +220,29 @@ 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); +const char *ramblock_name;int i; - packet->pages_alloc =be32_to_cpu (packet->pages_alloc); -/* -* If we received a packet that is 100 times bigger than expected -* just stop migration. It is a magic number. -*/ -if (packet->pages_alloc > page_count) { -error_setg (errp,"multifd: received packet " -"with size %u and expected a size of %u" , - packet->pages_alloc, page_count) ; +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 > packet->pages_alloc) { -error_setg (errp,"multifd: received packet " -"with %u normal pages and expected maximum pages are %u" , - p->normal_num, packet->pages_alloc) ; +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 > packet->pages_alloc - p->normal_num) { -error_setg (errp,"multifd: received packet " -"with %u zero pages and expected maximum zero pages are %u" , - p->zero_num, packet->pages_alloc - p->normal_num) ; +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 ; }
migration/multifd-nocomp.c int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp) · line 253
Quoted 7 lines
migration/multifd-nocomp.c +1
-3@@ -254,12 +250,10 @@ int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp)return 0 ; } -/* make sure that ramblock is 0 terminated */ - packet->ramblock[255 ] =0 ; - p->block =qemu_ram_block_by_name (packet->ramblock); + ramblock_name =g_strndup (packet->ramblock,255 );
This one is leaked?
IMHO the "temp var for endianess" is better justified than this specific one, where I think always null-terminating the packet->ramblock[] doesn't sound too bad - it makes sure all future ref to packet->ramblock is safe.
Quoted 45 lines
migration/multifd-nocomp.c +2
-2+ p->block =qemu_ram_block_by_name (ramblock_name);if (!p->block) { -error_setg (errp,"multifd: unknown ram block %s" , - packet->ramblock); +error_setg (errp,"multifd: unknown ram block %s" , ramblock_name);return -1 ; }migration/multifd.c +8
-10@@ -231,21 +231,19 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; +uint32_t magic =be32_to_cpu (packet->magic); +uint32_t version =be32_to_cpu (packet->version);int ret =0 ; - packet->magic =be32_to_cpu (packet->magic); -if (packet->magic !=MULTIFD_MAGIC ) { -error_setg (errp,"multifd: received packet " -"magic %x and expected magic %x" , - packet->magic,MULTIFD_MAGIC ); +if (magic !=MULTIFD_MAGIC ) { +error_setg (errp,"multifd: received packet magic %x, expected %x" , + magic,MULTIFD_MAGIC );return -1 ; } - packet->version =be32_to_cpu (packet->version); -if (packet->version !=MULTIFD_VERSION ) { -error_setg (errp,"multifd: received packet " -"version %u and expected version %u" , - packet->version,MULTIFD_VERSION ); +if (version !=MULTIFD_VERSION ) { +error_setg (errp,"multifd: received packet version %u, expected %u" , + version,MULTIFD_VERSION );return -1 ; }Signature · 1 line
2.35.3
Signature · 1 line
Peter Xu
Re: [PATCH v5 18/18] migration/multifd: Stop changing the packet on recv side
Quoted 84 lines · Peter Xu
Quoted 73 lines · Fabiano Rosas
As observed by Philippe, the
multifd_ram_unfill_packet()function currently leaves the MultiFDPacket structure with mixed endianness. This is harmless, but ultimately not very clean. Aside from that, the packet is also written to on the recv side to ensure the ramblock name is null-terminated.Stop touching the received packet and do the necessary work using stack variables instead.
While here tweak the error strings and fix the space before semicolons. Also remove the "100 times bigger" comment because it's just one possible explanation for a size mismatch and it doesn't even match the code.
CC Philippe Mathieu-Daudé <[email protected]>Signed-off-by Fabiano Rosas <[email protected]>--- migration/multifd-nocomp.c | 38 ++++++++++++++++---------------------- migration/multifd.c | 18 ++++++++---------- 2 files changed, 24 insertions(+), 32 deletions(-)migration/multifd-nocomp.c +13
-17@@ -220,33 +220,29 @@ 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); +const char *ramblock_name;int i; - packet->pages_alloc =be32_to_cpu (packet->pages_alloc); -/* -* If we received a packet that is 100 times bigger than expected -* just stop migration. It is a magic number. -*/ -if (packet->pages_alloc > page_count) { -error_setg (errp,"multifd: received packet " -"with size %u and expected a size of %u" , - packet->pages_alloc, page_count) ; +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 > packet->pages_alloc) { -error_setg (errp,"multifd: received packet " -"with %u normal pages and expected maximum pages are %u" , - p->normal_num, packet->pages_alloc) ; +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 > packet->pages_alloc - p->normal_num) { -error_setg (errp,"multifd: received packet " -"with %u zero pages and expected maximum zero pages are %u" , - p->zero_num, packet->pages_alloc - p->normal_num) ; +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 ; }migration/multifd-nocomp.c int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp) · line 253
Quoted 7 lines
migration/multifd-nocomp.c +1
-3@@ -254,12 +250,10 @@ int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp)return 0 ; } -/* make sure that ramblock is 0 terminated */ - packet->ramblock[255 ] =0 ; - p->block =qemu_ram_block_by_name (packet->ramblock); + ramblock_name =g_strndup (packet->ramblock,255 );This one is leaked?
Quoted 3 lines
IMHO the "temp var for endianess" is better justified than this specific one, where I think always null-terminating the packet->ramblock[] doesn't sound too bad - it makes sure all future ref to
packet->ramblockis safe.
Ok, I can drop this part.
Quoted 46 lines
Quoted 46 lines
migration/multifd-nocomp.c +2
-2+ p->block =qemu_ram_block_by_name (ramblock_name);if (!p->block) { -error_setg (errp,"multifd: unknown ram block %s" , - packet->ramblock); +error_setg (errp,"multifd: unknown ram block %s" , ramblock_name);return -1 ; }migration/multifd.c +8
-10@@ -231,21 +231,19 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; +uint32_t magic =be32_to_cpu (packet->magic); +uint32_t version =be32_to_cpu (packet->version);int ret =0 ; - packet->magic =be32_to_cpu (packet->magic); -if (packet->magic !=MULTIFD_MAGIC ) { -error_setg (errp,"multifd: received packet " -"magic %x and expected magic %x" , - packet->magic,MULTIFD_MAGIC ); +if (magic !=MULTIFD_MAGIC ) { +error_setg (errp,"multifd: received packet magic %x, expected %x" , + magic,MULTIFD_MAGIC );return -1 ; } - packet->version =be32_to_cpu (packet->version); -if (packet->version !=MULTIFD_VERSION ) { -error_setg (errp,"multifd: received packet " -"version %u and expected version %u" , - packet->version,MULTIFD_VERSION ); +if (version !=MULTIFD_VERSION ) { +error_setg (errp,"multifd: received packet version %u, expected %u" , + version,MULTIFD_VERSION );return -1 ; }Signature · 1 line
2.35.3
Re: [PATCH v5 18/18] migration/multifd: Stop changing the packet on recv side
In reply to Peter XuQuoted 84 lines · Peter Xu
Quoted 73 lines · Fabiano Rosas
As observed by Philippe, the
multifd_ram_unfill_packet()function currently leaves the MultiFDPacket structure with mixed endianness. This is harmless, but ultimately not very clean. Aside from that, the packet is also written to on the recv side to ensure the ramblock name is null-terminated.Stop touching the received packet and do the necessary work using stack variables instead.
While here tweak the error strings and fix the space before semicolons. Also remove the "100 times bigger" comment because it's just one possible explanation for a size mismatch and it doesn't even match the code.
CC Philippe Mathieu-Daudé <[email protected]>Signed-off-by Fabiano Rosas <[email protected]>--- migration/multifd-nocomp.c | 38 ++++++++++++++++---------------------- migration/multifd.c | 18 ++++++++---------- 2 files changed, 24 insertions(+), 32 deletions(-)migration/multifd-nocomp.c +13
-17@@ -220,33 +220,29 @@ 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); +const char *ramblock_name;int i; - packet->pages_alloc =be32_to_cpu (packet->pages_alloc); -/* -* If we received a packet that is 100 times bigger than expected -* just stop migration. It is a magic number. -*/ -if (packet->pages_alloc > page_count) { -error_setg (errp,"multifd: received packet " -"with size %u and expected a size of %u" , - packet->pages_alloc, page_count) ; +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 > packet->pages_alloc) { -error_setg (errp,"multifd: received packet " -"with %u normal pages and expected maximum pages are %u" , - p->normal_num, packet->pages_alloc) ; +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 > packet->pages_alloc - p->normal_num) { -error_setg (errp,"multifd: received packet " -"with %u zero pages and expected maximum zero pages are %u" , - p->zero_num, packet->pages_alloc - p->normal_num) ; +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 ; }migration/multifd-nocomp.c int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp) · line 253
Quoted 7 lines
migration/multifd-nocomp.c +1
-3@@ -254,12 +250,10 @@ int multifd_ram_unfill_packet(MultiFDRecvParams *p, Error **errp)return 0 ; } -/* make sure that ramblock is 0 terminated */ - packet->ramblock[255 ] =0 ; - p->block =qemu_ram_block_by_name (packet->ramblock); + ramblock_name =g_strndup (packet->ramblock,255 );This one is leaked?
Quoted 3 lines
IMHO the "temp var for endianess" is better justified than this specific one, where I think always null-terminating the packet->ramblock[] doesn't sound too bad - it makes sure all future ref to
packet->ramblockis safe.
OTOH we can make MultiFDPacket_t const to be sure we don't alter it:
-- >8 --
migration/multifd-nocomp.c +2 -2
@@ -217,11 +217,11 @@ void multifd_ram_fill_packet(MultiFDSendParams *p)int multifd_ram_unfill_packet (MultiFDRecvParams *p,Error **errp) { -MultiFDPacket_t *packet = p->packet; +const 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); -const char *ramblock_name; + g_autofree const char *ramblock_name = NULL;int i;if (pages_per_packet > page_count) {
migration/multifd.c +1 -1
@@ -230,7 +230,7 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) { -MultiFDPacket_t *packet = p->packet; +const MultiFDPacket_t *packet = p->packet;uint32_t magic =be32_to_cpu (packet->magic);uint32_t version =be32_to_cpu (packet->version);int ret =0 ;
---
Quoted 47 lines
Quoted 46 lines
migration/multifd-nocomp.c +2
-2+ p->block =qemu_ram_block_by_name (ramblock_name);if (!p->block) { -error_setg (errp,"multifd: unknown ram block %s" , - packet->ramblock); +error_setg (errp,"multifd: unknown ram block %s" , ramblock_name);return -1 ; }migration/multifd.c +8
-10@@ -231,21 +231,19 @@ void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; +uint32_t magic =be32_to_cpu (packet->magic); +uint32_t version =be32_to_cpu (packet->version);int ret =0 ; - packet->magic =be32_to_cpu (packet->magic); -if (packet->magic !=MULTIFD_MAGIC ) { -error_setg (errp,"multifd: received packet " -"magic %x and expected magic %x" , - packet->magic,MULTIFD_MAGIC ); +if (magic !=MULTIFD_MAGIC ) { +error_setg (errp,"multifd: received packet magic %x, expected %x" , + magic,MULTIFD_MAGIC );return -1 ; } - packet->version =be32_to_cpu (packet->version); -if (packet->version !=MULTIFD_VERSION ) { -error_setg (errp,"multifd: received packet " -"version %u and expected version %u" , - packet->version,MULTIFD_VERSION ); +if (version !=MULTIFD_VERSION ) { +error_setg (errp,"multifd: received packet version %u, expected %u" , + version,MULTIFD_VERSION );return -1 ; }Signature · 1 line
2.35.3