2 * Multifd zlib compression implementation
4 * Copyright (c) 2020 Red Hat Inc
7 * Juan Quintela <quintela@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
16 #include "exec/ramblock.h"
17 #include "exec/target_page.h"
18 #include "qapi/error.h"
19 #include "migration.h"
24 /* stream for compression */
26 /* compressed buffer */
28 /* size of compressed buffer */
32 /* Multifd zlib compression */
35 * zlib_send_setup: setup send side
37 * Setup each channel with zlib compression.
39 * Returns 0 for success or -1 for error
41 * @p: Params for the channel that we are using
42 * @errp: pointer to an error
44 static int zlib_send_setup(MultiFDSendParams *p, Error **errp)
46 struct zlib_data *z = g_malloc0(sizeof(struct zlib_data));
47 z_stream *zs = &z->zs;
52 if (deflateInit(zs, migrate_multifd_zlib_level()) != Z_OK) {
54 error_setg(errp, "multifd %d: deflate init failed", p->id);
57 /* To be safe, we reserve twice the size of the packet */
58 z->zbuff_len = MULTIFD_PACKET_SIZE * 2;
59 z->zbuff = g_try_malloc(z->zbuff_len);
63 error_setg(errp, "multifd %d: out of memory for zbuff", p->id);
71 * zlib_send_cleanup: cleanup send side
73 * Close the channel and return memory.
75 * @p: Params for the channel that we are using
76 * @errp: pointer to an error
78 static void zlib_send_cleanup(MultiFDSendParams *p, Error **errp)
80 struct zlib_data *z = p->data;
90 * zlib_send_prepare: prepare date to be able to send
92 * Create a compressed buffer with all the pages that we are going to
95 * Returns 0 for success or -1 for error
97 * @p: Params for the channel that we are using
98 * @errp: pointer to an error
100 static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)
102 struct zlib_data *z = p->data;
103 size_t page_size = qemu_target_page_size();
104 z_stream *zs = &z->zs;
105 uint32_t out_size = 0;
109 for (i = 0; i < p->pages->num; i++) {
110 uint32_t available = z->zbuff_len - out_size;
111 int flush = Z_NO_FLUSH;
113 if (i == p->pages->num - 1) {
114 flush = Z_SYNC_FLUSH;
117 zs->avail_in = page_size;
118 zs->next_in = p->pages->block->host + p->pages->offset[i];
120 zs->avail_out = available;
121 zs->next_out = z->zbuff + out_size;
124 * Welcome to deflate semantics
126 * We need to loop while:
128 * - there are stuff to be compressed
129 * - there are output space free
132 ret = deflate(zs, flush);
133 } while (ret == Z_OK && zs->avail_in && zs->avail_out);
134 if (ret == Z_OK && zs->avail_in) {
135 error_setg(errp, "multifd %d: deflate failed to compress all input",
140 error_setg(errp, "multifd %d: deflate returned %d instead of Z_OK",
144 out_size += available - zs->avail_out;
146 p->next_packet_size = out_size;
147 p->flags |= MULTIFD_FLAG_ZLIB;
153 * zlib_send_write: do the actual write of the data
155 * Do the actual write of the comprresed buffer.
157 * Returns 0 for success or -1 for error
159 * @p: Params for the channel that we are using
160 * @used: number of pages used
161 * @errp: pointer to an error
163 static int zlib_send_write(MultiFDSendParams *p, uint32_t used, Error **errp)
165 struct zlib_data *z = p->data;
167 return qio_channel_write_all(p->c, (void *)z->zbuff, p->next_packet_size,
172 * zlib_recv_setup: setup receive side
174 * Create the compressed channel and buffer.
176 * Returns 0 for success or -1 for error
178 * @p: Params for the channel that we are using
179 * @errp: pointer to an error
181 static int zlib_recv_setup(MultiFDRecvParams *p, Error **errp)
183 struct zlib_data *z = g_malloc0(sizeof(struct zlib_data));
184 z_stream *zs = &z->zs;
191 zs->next_in = Z_NULL;
192 if (inflateInit(zs) != Z_OK) {
193 error_setg(errp, "multifd %d: inflate init failed", p->id);
196 /* To be safe, we reserve twice the size of the packet */
197 z->zbuff_len = MULTIFD_PACKET_SIZE * 2;
198 z->zbuff = g_try_malloc(z->zbuff_len);
201 error_setg(errp, "multifd %d: out of memory for zbuff", p->id);
208 * zlib_recv_cleanup: setup receive side
210 * For no compression this function does nothing.
212 * @p: Params for the channel that we are using
214 static void zlib_recv_cleanup(MultiFDRecvParams *p)
216 struct zlib_data *z = p->data;
226 * zlib_recv_pages: read the data from the channel into actual pages
228 * Read the compressed buffer, and uncompress it into the actual
231 * Returns 0 for success or -1 for error
233 * @p: Params for the channel that we are using
234 * @errp: pointer to an error
236 static int zlib_recv_pages(MultiFDRecvParams *p, Error **errp)
238 struct zlib_data *z = p->data;
239 size_t page_size = qemu_target_page_size();
240 z_stream *zs = &z->zs;
241 uint32_t in_size = p->next_packet_size;
242 /* we measure the change of total_out */
243 uint32_t out_size = zs->total_out;
244 uint32_t expected_size = p->pages->num * qemu_target_page_size();
245 uint32_t flags = p->flags & MULTIFD_FLAG_COMPRESSION_MASK;
249 if (flags != MULTIFD_FLAG_ZLIB) {
250 error_setg(errp, "multifd %d: flags received %x flags expected %x",
251 p->id, flags, MULTIFD_FLAG_ZLIB);
254 ret = qio_channel_read_all(p->c, (void *)z->zbuff, in_size, errp);
260 zs->avail_in = in_size;
261 zs->next_in = z->zbuff;
263 for (i = 0; i < p->pages->num; i++) {
264 int flush = Z_NO_FLUSH;
265 unsigned long start = zs->total_out;
267 if (i == p->pages->num - 1) {
268 flush = Z_SYNC_FLUSH;
271 zs->avail_out = page_size;
272 zs->next_out = p->pages->block->host + p->pages->offset[i];
275 * Welcome to inflate semantics
277 * We need to loop while:
279 * - there are input available
280 * - we haven't completed a full page
283 ret = inflate(zs, flush);
284 } while (ret == Z_OK && zs->avail_in
285 && (zs->total_out - start) < page_size);
286 if (ret == Z_OK && (zs->total_out - start) < page_size) {
287 error_setg(errp, "multifd %d: inflate generated too few output",
292 error_setg(errp, "multifd %d: inflate returned %d instead of Z_OK",
297 out_size = zs->total_out - out_size;
298 if (out_size != expected_size) {
299 error_setg(errp, "multifd %d: packet size received %d size expected %d",
300 p->id, out_size, expected_size);
306 static MultiFDMethods multifd_zlib_ops = {
307 .send_setup = zlib_send_setup,
308 .send_cleanup = zlib_send_cleanup,
309 .send_prepare = zlib_send_prepare,
310 .send_write = zlib_send_write,
311 .recv_setup = zlib_recv_setup,
312 .recv_cleanup = zlib_recv_cleanup,
313 .recv_pages = zlib_recv_pages
316 static void multifd_zlib_register(void)
318 multifd_register_ops(MULTIFD_COMPRESSION_ZLIB, &multifd_zlib_ops);
321 migration_init(multifd_zlib_register);