mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

migration/multifd: Inline page_size and page_count

Browse Source 
The 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.

Reviewed-by: Peter Xu <peterx@redhat.com>
Signed-off-by: Fabiano Rosas <farosas@suse.de>
This commit is contained in:
Fabiano Rosas 2024-08-27 14:45:49 -03:00
parent bc112a6c90
commit 90fa121c6c
7 changed files with 71 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
migration/multifd-qpl.c
View File

@ -233,8 +233,10 @@ static void multifd_qpl_deinit(QplData *qpl)
static int multifd_qpl_send_setup(MultiFDSendParams *p, Error **errp) static int multifd_qpl_send_setup(MultiFDSendParams *p, Error **errp)
{ {
QplData *qpl; 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) { if (!qpl) {
return -1; 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 * additional two IOVs are used to store packet header and compressed data
* length * length
*/ */
p->iov = g_new0(struct iovec, p->page_count + 2); p->iov = g_new0(struct iovec, page_count + 2);
return 0; return 0;
} }
@ -534,8 +536,10 @@ out:
static int multifd_qpl_recv_setup(MultiFDRecvParams *p, Error **errp) static int multifd_qpl_recv_setup(MultiFDRecvParams *p, Error **errp)
{ {
QplData *qpl; 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) { if (!qpl) {
return -1; return -1;
} }

36
migration/multifd-uadk.c
View File

@ -114,8 +114,10 @@ static void multifd_uadk_uninit_sess(struct wd_data *wd)
static int multifd_uadk_send_setup(MultiFDSendParams *p, Error **errp) static int multifd_uadk_send_setup(MultiFDSendParams *p, Error **errp)
{ {
struct wd_data *wd; 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) { if (!wd) {
return -1; return -1;
} }
@ -128,7 +130,7 @@ static int multifd_uadk_send_setup(MultiFDSendParams *p, Error **errp)
* length * length
*/ */
p->iov = g_new0(struct iovec, p->page_count + 2); p->iov = g_new0(struct iovec, page_count + 2);
return 0; return 0;
} }
@ -172,6 +174,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)
{ {
struct wd_data *uadk_data = p->compress_data; struct wd_data *uadk_data = p->compress_data;
uint32_t hdr_size; uint32_t hdr_size;
uint32_t page_size = multifd_ram_page_size();
uint8_t *buf = uadk_data->buf; uint8_t *buf = uadk_data->buf;
int ret = 0; int ret = 0;
MultiFDPages_t *pages = p->pages; MultiFDPages_t *pages = p->pages;
@ -188,7 +191,7 @@ static int multifd_uadk_send_prepare(MultiFDSendParams *p, Error **errp)
struct wd_comp_req creq = { struct wd_comp_req creq = {
.op_type = WD_DIR_COMPRESS, .op_type = WD_DIR_COMPRESS,
.src = pages->block->host + pages->offset[i], .src = pages->block->host + pages->offset[i],
.src_len = p->page_size, .src_len = page_size,
.dst = buf, .dst = buf,
/* Set dst_len to double the src in case compressed out >= page_size */ /* Set dst_len to double the src in case compressed out >= page_size */
.dst_len = p->page_size * 2, .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); p->id, ret, creq.status);
return -1; 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); uadk_data->buf_hdr[i] = cpu_to_be32(creq.dst_len);
prepare_next_iov(p, buf, creq.dst_len); prepare_next_iov(p, buf, creq.dst_len);
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 * 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. * decompression. But it is tricky to find the right number here.
*/ */
if (!uadk_data->handle || creq.dst_len >= p->page_size) { if (!uadk_data->handle || creq.dst_len >= page_size) {
uadk_data->buf_hdr[i] = cpu_to_be32(p->page_size); uadk_data->buf_hdr[i] = cpu_to_be32(page_size);
prepare_next_iov(p, pages->block->host + pages->offset[i], prepare_next_iov(p, pages->block->host + pages->offset[i],
p->page_size); page_size);
buf += p->page_size; buf += page_size;
} }
} }
out: out:
@ -239,8 +242,10 @@ out:
static int multifd_uadk_recv_setup(MultiFDRecvParams *p, Error **errp) static int multifd_uadk_recv_setup(MultiFDRecvParams *p, Error **errp)
{ {
struct wd_data *wd; 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) { if (!wd) {
return -1; 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 flags = p->flags & MULTIFD_FLAG_COMPRESSION_MASK;
uint32_t hdr_len = p->normal_num * sizeof(uint32_t); uint32_t hdr_len = p->normal_num * sizeof(uint32_t);
uint32_t data_len = 0; uint32_t data_len = 0;
uint32_t page_size = multifd_ram_page_size();
uint8_t *buf = uadk_data->buf; uint8_t *buf = uadk_data->buf;
int ret = 0; 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++) { for (int i = 0; i < p->normal_num; i++) {
uadk_data->buf_hdr[i] = be32_to_cpu(uadk_data->buf_hdr[i]); uadk_data->buf_hdr[i] = be32_to_cpu(uadk_data->buf_hdr[i]);
data_len += 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 */ /* read compressed data */
@ -323,12 +329,12 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp)
.src = buf, .src = buf,
.src_len = uadk_data->buf_hdr[i], .src_len = uadk_data->buf_hdr[i],
.dst = p->host + p->normal[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) { if (uadk_data->buf_hdr[i] == page_size) {
memcpy(p->host + p->normal[i], buf, p->page_size); memcpy(p->host + p->normal[i], buf, page_size);
buf += p->page_size; buf += page_size;
continue; continue;
} }
@ -344,7 +350,7 @@ static int multifd_uadk_recv(MultiFDRecvParams *p, Error **errp)
p->id, ret, creq.status); p->id, ret, creq.status);
return -1; 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); error_setg(errp, "multifd %u: decompressed length error", p->id);
return -1; return -1;
} }

4
migration/multifd-zero-page.c
View File

@ -63,7 +63,7 @@ void multifd_send_zero_page_detect(MultiFDSendParams *p)
while (i <= j) { while (i <= j) {
uint64_t offset = pages->offset[i]; 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++; i++;
continue; continue;
} }
@ -81,7 +81,7 @@ void multifd_recv_zero_page_process(MultiFDRecvParams *p)
for (int i = 0; i < p->zero_num; i++) { for (int i = 0; i < p->zero_num; i++) {
void *page = p->host + p->zero[i]; void *page = p->host + p->zero[i];
if (ramblock_recv_bitmap_test_byte_offset(p->block, 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 { } else {
ramblock_recv_bitmap_set_offset(p->block, p->zero[i]); ramblock_recv_bitmap_set_offset(p->block, p->zero[i]);
} }

14
migration/multifd-zlib.c
View File

@ -127,6 +127,7 @@ static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)
struct zlib_data *z = p->compress_data; struct zlib_data *z = p->compress_data;
z_stream *zs = &z->zs; z_stream *zs = &z->zs;
uint32_t out_size = 0; uint32_t out_size = 0;
uint32_t page_size = multifd_ram_page_size();
int ret; int ret;
uint32_t i; 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, * with compression. zlib does not guarantee that this is safe,
* therefore copy the page before calling deflate(). * therefore copy the page before calling deflate().
*/ */
memcpy(z->buf, pages->block->host + pages->offset[i], p->page_size); memcpy(z->buf, pages->block->host + pages->offset[i], page_size);
zs->avail_in = p->page_size; zs->avail_in = page_size;
zs->next_in = z->buf; zs->next_in = z->buf;
zs->avail_out = available; zs->avail_out = available;
@ -260,7 +261,8 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp)
uint32_t in_size = p->next_packet_size; uint32_t in_size = p->next_packet_size;
/* we measure the change of total_out */ /* we measure the change of total_out */
uint32_t out_size = zs->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; uint32_t flags = p->flags & MULTIFD_FLAG_COMPRESSION_MASK;
int ret; int ret;
int i; int i;
@ -296,7 +298,7 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp)
flush = Z_SYNC_FLUSH; flush = Z_SYNC_FLUSH;
} }
zs->avail_out = p->page_size; zs->avail_out = page_size;
zs->next_out = p->host + p->normal[i]; zs->next_out = p->host + p->normal[i];
/* /*
@ -310,8 +312,8 @@ static int zlib_recv(MultiFDRecvParams *p, Error **errp)
do { do {
ret = inflate(zs, flush); ret = inflate(zs, flush);
} while (ret == Z_OK && zs->avail_in } while (ret == Z_OK && zs->avail_in
&& (zs->total_out - start) < p->page_size); && (zs->total_out - start) < page_size);
if (ret == Z_OK && (zs->total_out - start) < p->page_size) { if (ret == Z_OK && (zs->total_out - start) < page_size) {
error_setg(errp, "multifd %u: inflate generated too few output", error_setg(errp, "multifd %u: inflate generated too few output",
p->id); p->id);
return -1; return -1;

11
migration/multifd-zstd.c
View File

@ -139,7 +139,7 @@ static int zstd_send_prepare(MultiFDSendParams *p, Error **errp)
flush = ZSTD_e_flush; flush = ZSTD_e_flush;
} }
z->in.src = pages->block->host + pages->offset[i]; 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; 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 in_size = p->next_packet_size;
uint32_t out_size = 0; 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; uint32_t flags = p->flags & MULTIFD_FLAG_COMPRESSION_MASK;
struct zstd_data *z = p->compress_data; struct zstd_data *z = p->compress_data;
int ret; int ret;
@ -286,7 +287,7 @@ static int zstd_recv(MultiFDRecvParams *p, Error **errp)
for (i = 0; i < p->normal_num; i++) { for (i = 0; i < p->normal_num; i++) {
ramblock_recv_bitmap_set_offset(p->block, p->normal[i]); ramblock_recv_bitmap_set_offset(p->block, p->normal[i]);
z->out.dst = p->host + 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; z->out.pos = 0;
/* /*
@ -300,8 +301,8 @@ static int zstd_recv(MultiFDRecvParams *p, Error **errp)
do { do {
ret = ZSTD_decompressStream(z->zds, &z->out, &z->in); ret = ZSTD_decompressStream(z->zds, &z->out, &z->in);
} while (ret > 0 && (z->in.size - z->in.pos > 0) } while (ret > 0 && (z->in.size - z->in.pos > 0)
&& (z->out.pos < p->page_size)); && (z->out.pos < page_size));
if (ret > 0 && (z->out.pos < p->page_size)) { if (ret > 0 && (z->out.pos < page_size)) {
error_setg(errp, "multifd %u: decompressStream buffer too small", error_setg(errp, "multifd %u: decompressStream buffer too small",
p->id); p->id);
return -1; return -1;

33
migration/multifd.c
View File

@ -133,15 +133,17 @@ static void multifd_set_file_bitmap(MultiFDSendParams *p)
*/ */
static int nocomp_send_setup(MultiFDSendParams *p, Error **errp) static int nocomp_send_setup(MultiFDSendParams *p, Error **errp)
{ {
uint32_t page_count = multifd_ram_page_count();
if (migrate_zero_copy_send()) { if (migrate_zero_copy_send()) {
p->write_flags |= QIO_CHANNEL_WRITE_FLAG_ZERO_COPY; p->write_flags |= QIO_CHANNEL_WRITE_FLAG_ZERO_COPY;
} }
if (multifd_use_packets()) { if (multifd_use_packets()) {
/* We need one extra place for the packet header */ /* 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 { } else {
p->iov = g_new0(struct iovec, p->page_count); p->iov = g_new0(struct iovec, page_count);
} }
return 0; return 0;
@ -165,14 +167,15 @@ static void nocomp_send_cleanup(MultiFDSendParams *p, Error **errp)
static void multifd_send_prepare_iovs(MultiFDSendParams *p) static void multifd_send_prepare_iovs(MultiFDSendParams *p)
{ {
MultiFDPages_t *pages = p->pages; MultiFDPages_t *pages = p->pages;
uint32_t page_size = multifd_ram_page_size();
for (int i = 0; i < pages->normal_num; i++) { 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_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->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) 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; return 0;
} }
@ -288,7 +291,7 @@ static int nocomp_recv(MultiFDRecvParams *p, Error **errp)
for (int i = 0; i < p->normal_num; i++) { for (int i = 0; i < p->normal_num; i++) {
p->iov[i].iov_base = p->host + p->normal[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]); ramblock_recv_bitmap_set_offset(p->block, p->normal[i]);
} }
return qio_channel_readv_all(p->c, p->iov, p->normal_num, errp); 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) static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)
{ {
MultiFDPacket_t *packet = p->packet; MultiFDPacket_t *packet = p->packet;
uint32_t page_count = multifd_ram_page_count();
uint32_t page_size = multifd_ram_page_size();
int i; int i;
packet->magic = be32_to_cpu(packet->magic); 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 * If we received a packet that is 100 times bigger than expected
* just stop migration. It is a magic number. * 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 " error_setg(errp, "multifd: received packet "
"with size %u and expected a size of %u", "with size %u and expected a size of %u",
packet->pages_alloc, p->page_count) ; packet->pages_alloc, page_count) ;
return -1; return -1;
} }
@ -521,7 +526,7 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)
for (i = 0; i < p->normal_num; i++) { for (i = 0; i < p->normal_num; i++) {
uint64_t offset = be64_to_cpu(packet->offset[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 error_setg(errp, "multifd: offset too long %" PRIu64
" (max " RAM_ADDR_FMT ")", " (max " RAM_ADDR_FMT ")",
offset, p->block->used_length); 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++) { for (i = 0; i < p->zero_num; i++) {
uint64_t offset = be64_to_cpu(packet->offset[p->normal_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 error_setg(errp, "multifd: offset too long %" PRIu64
" (max " RAM_ADDR_FMT ")", " (max " RAM_ADDR_FMT ")",
offset, p->block->used_length); offset, p->block->used_length);
@ -1157,7 +1162,7 @@ bool multifd_send_setup(void)
{ {
MigrationState *s = migrate_get_current(); MigrationState *s = migrate_get_current();
int thread_count, ret = 0; 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(); bool use_packets = multifd_use_packets();
uint8_t i; uint8_t i;
@ -1191,8 +1196,6 @@ bool multifd_send_setup(void)
p->packet->version = cpu_to_be32(MULTIFD_VERSION); p->packet->version = cpu_to_be32(MULTIFD_VERSION);
} }
p->name = g_strdup_printf("mig/src/send_%d", i); 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; p->write_flags = 0;
if (!multifd_new_send_channel_create(p, &local_err)) { 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 multifd_recv_setup(Error **errp)
{ {
int thread_count; 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(); bool use_packets = multifd_use_packets();
uint8_t i; uint8_t i;
@ -1613,8 +1616,6 @@ int multifd_recv_setup(Error **errp)
p->name = g_strdup_printf("mig/dst/recv_%d", i); p->name = g_strdup_printf("mig/dst/recv_%d", i);
p->normal = g_new0(ram_addr_t, page_count); p->normal = g_new0(ram_addr_t, page_count);
p->zero = 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++) { for (i = 0; i < thread_count; i++) {

18
migration/multifd.h
View File

@ -13,6 +13,7 @@
#ifndef QEMU_MIGRATION_MULTIFD_H #ifndef QEMU_MIGRATION_MULTIFD_H
#define QEMU_MIGRATION_MULTIFD_H #define QEMU_MIGRATION_MULTIFD_H
#include "exec/target_page.h"
#include "ram.h" #include "ram.h"
typedef struct MultiFDRecvData MultiFDRecvData; typedef struct MultiFDRecvData MultiFDRecvData;
@ -106,10 +107,6 @@ typedef struct {
QIOChannel *c; QIOChannel *c;
/* packet allocated len */ /* packet allocated len */
uint32_t packet_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 */ /* multifd flags for sending ram */
int write_flags; int write_flags;
@ -173,10 +170,6 @@ typedef struct {
QIOChannel *c; QIOChannel *c;
/* packet allocated len */ /* packet allocated len */
uint32_t packet_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 */ /* syncs main thread and channels */
QemuSemaphore sem_sync; QemuSemaphore sem_sync;
@ -254,4 +247,13 @@ static inline void multifd_send_prepare_header(MultiFDSendParams *p)
void multifd_channel_connect(MultiFDSendParams *p, QIOChannel *ioc); 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 #endif