blob: 60c975db2b3455ba243efc89ea5a67185660fb78 [file] [log] [blame]
Blue Swirlad960902010-03-29 19:23:52 +00001/*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24#include <stdint.h>
25#include <stdarg.h>
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +020026#include <stdlib.h>
Blue Swirlad960902010-03-29 19:23:52 +000027#ifndef _WIN32
Blue Swirl1c47cb12010-03-30 19:27:34 +000028#include <sys/types.h>
Blue Swirlad960902010-03-29 19:23:52 +000029#include <sys/mman.h>
30#endif
31#include "config.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010032#include "monitor/monitor.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010033#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010034#include "qemu/bitops.h"
35#include "qemu/bitmap.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010036#include "sysemu/arch_init.h"
Blue Swirlad960902010-03-29 19:23:52 +000037#include "audio/audio.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010038#include "hw/i386/pc.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020039#include "hw/pci/pci.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010040#include "hw/audio/audio.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010041#include "sysemu/kvm.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010042#include "migration/migration.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010043#include "hw/i386/smbios.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010044#include "exec/address-spaces.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010045#include "hw/audio/pcspk.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010046#include "migration/page_cache.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010047#include "qemu/config-file.h"
Daniel P. Berrange99afc912012-08-20 15:31:38 +010048#include "qmp-commands.h"
Juan Quintela3c121932012-09-04 13:08:57 +020049#include "trace.h"
Paolo Bonzini0d6d3c82012-11-14 15:45:02 +010050#include "exec/cpu-all.h"
Juan Quintela12291ec2013-10-14 17:14:47 +020051#include "exec/ram_addr.h"
Michael S. Tsirkin04452592013-04-15 09:19:22 +030052#include "hw/acpi/acpi.h"
Juan Quintelaaa8dc042013-11-06 11:33:05 +010053#include "qemu/host-utils.h"
Blue Swirlad960902010-03-29 19:23:52 +000054
Orit Wasserman3a697f62012-06-19 18:43:15 +030055#ifdef DEBUG_ARCH_INIT
56#define DPRINTF(fmt, ...) \
57 do { fprintf(stdout, "arch_init: " fmt, ## __VA_ARGS__); } while (0)
58#else
59#define DPRINTF(fmt, ...) \
60 do { } while (0)
61#endif
62
Blue Swirlad960902010-03-29 19:23:52 +000063#ifdef TARGET_SPARC
64int graphic_width = 1024;
65int graphic_height = 768;
66int graphic_depth = 8;
67#else
68int graphic_width = 800;
69int graphic_height = 600;
Alexander Graff1ff0e82013-06-20 14:06:27 +020070int graphic_depth = 32;
Blue Swirlad960902010-03-29 19:23:52 +000071#endif
72
Blue Swirlad960902010-03-29 19:23:52 +000073
74#if defined(TARGET_ALPHA)
75#define QEMU_ARCH QEMU_ARCH_ALPHA
76#elif defined(TARGET_ARM)
77#define QEMU_ARCH QEMU_ARCH_ARM
78#elif defined(TARGET_CRIS)
79#define QEMU_ARCH QEMU_ARCH_CRIS
80#elif defined(TARGET_I386)
81#define QEMU_ARCH QEMU_ARCH_I386
82#elif defined(TARGET_M68K)
83#define QEMU_ARCH QEMU_ARCH_M68K
Michael Walle81ea0e12011-02-17 23:45:02 +010084#elif defined(TARGET_LM32)
85#define QEMU_ARCH QEMU_ARCH_LM32
Blue Swirlad960902010-03-29 19:23:52 +000086#elif defined(TARGET_MICROBLAZE)
87#define QEMU_ARCH QEMU_ARCH_MICROBLAZE
88#elif defined(TARGET_MIPS)
89#define QEMU_ARCH QEMU_ARCH_MIPS
Anthony Greend15a9c22013-03-18 15:49:25 -040090#elif defined(TARGET_MOXIE)
91#define QEMU_ARCH QEMU_ARCH_MOXIE
Jia Liue67db062012-07-20 15:50:39 +080092#elif defined(TARGET_OPENRISC)
93#define QEMU_ARCH QEMU_ARCH_OPENRISC
Blue Swirlad960902010-03-29 19:23:52 +000094#elif defined(TARGET_PPC)
95#define QEMU_ARCH QEMU_ARCH_PPC
96#elif defined(TARGET_S390X)
97#define QEMU_ARCH QEMU_ARCH_S390X
98#elif defined(TARGET_SH4)
99#define QEMU_ARCH QEMU_ARCH_SH4
100#elif defined(TARGET_SPARC)
101#define QEMU_ARCH QEMU_ARCH_SPARC
Max Filippov23288262011-09-06 03:55:25 +0400102#elif defined(TARGET_XTENSA)
103#define QEMU_ARCH QEMU_ARCH_XTENSA
Guan Xuetao4f23a1e2012-08-10 14:42:21 +0800104#elif defined(TARGET_UNICORE32)
105#define QEMU_ARCH QEMU_ARCH_UNICORE32
Blue Swirlad960902010-03-29 19:23:52 +0000106#endif
107
108const uint32_t arch_type = QEMU_ARCH;
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600109static bool mig_throttle_on;
110static int dirty_rate_high_cnt;
111static void check_guest_throttling(void);
Blue Swirlad960902010-03-29 19:23:52 +0000112
113/***********************************************************/
114/* ram save/restore */
115
Yoshiaki Tamurad20878d2010-08-18 13:30:12 +0900116#define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
117#define RAM_SAVE_FLAG_COMPRESS 0x02
118#define RAM_SAVE_FLAG_MEM_SIZE 0x04
119#define RAM_SAVE_FLAG_PAGE 0x08
120#define RAM_SAVE_FLAG_EOS 0x10
121#define RAM_SAVE_FLAG_CONTINUE 0x20
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300122#define RAM_SAVE_FLAG_XBZRLE 0x40
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400123/* 0x80 is reserved in migration.h start with 0x100 next */
Blue Swirlad960902010-03-29 19:23:52 +0000124
Eduardo Habkost756557d2012-05-02 13:07:27 -0300125static struct defconfig_file {
126 const char *filename;
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300127 /* Indicates it is an user config file (disabled by -no-user-config) */
128 bool userconfig;
Eduardo Habkost756557d2012-05-02 13:07:27 -0300129} default_config_files[] = {
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300130 { CONFIG_QEMU_CONFDIR "/qemu.conf", true },
Paolo Bonzini2e599152013-06-04 14:45:27 +0200131 { CONFIG_QEMU_CONFDIR "/target-" TARGET_NAME ".conf", true },
Eduardo Habkost756557d2012-05-02 13:07:27 -0300132 { NULL }, /* end of list */
133};
134
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000135static const uint8_t ZERO_TARGET_PAGE[TARGET_PAGE_SIZE];
Eduardo Habkost756557d2012-05-02 13:07:27 -0300136
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300137int qemu_read_default_config_files(bool userconfig)
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300138{
139 int ret;
Eduardo Habkost756557d2012-05-02 13:07:27 -0300140 struct defconfig_file *f;
141
142 for (f = default_config_files; f->filename; f++) {
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300143 if (!userconfig && f->userconfig) {
144 continue;
145 }
Eduardo Habkost756557d2012-05-02 13:07:27 -0300146 ret = qemu_read_config_file(f->filename);
147 if (ret < 0 && ret != -ENOENT) {
148 return ret;
149 }
150 }
Laszlo Ersek4d8b3c62013-03-21 00:23:13 +0100151
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300152 return 0;
153}
154
Isaku Yamahatadc3c26a2013-09-21 01:23:36 +0900155static inline bool is_zero_range(uint8_t *p, uint64_t size)
Blue Swirlad960902010-03-29 19:23:52 +0000156{
Isaku Yamahatadc3c26a2013-09-21 01:23:36 +0900157 return buffer_find_nonzero_offset(p, size) == size;
Blue Swirlad960902010-03-29 19:23:52 +0000158}
159
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300160/* struct contains XBZRLE cache and a static page
161 used by the compression */
162static struct {
163 /* buffer used for XBZRLE encoding */
164 uint8_t *encoded_buf;
165 /* buffer for storing page content */
166 uint8_t *current_buf;
Gongleifd8cec92014-03-04 21:29:21 +0800167 /* Cache for XBZRLE, Protected by lock. */
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300168 PageCache *cache;
Gongleifd8cec92014-03-04 21:29:21 +0800169 QemuMutex lock;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300170} XBZRLE = {
171 .encoded_buf = NULL,
172 .current_buf = NULL,
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300173 .cache = NULL,
174};
Gonglei (Arei)905f26f2014-01-30 20:08:35 +0200175/* buffer used for XBZRLE decoding */
176static uint8_t *xbzrle_decoded_buf;
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300177
Gongleifd8cec92014-03-04 21:29:21 +0800178static void XBZRLE_cache_lock(void)
179{
180 if (migrate_use_xbzrle())
181 qemu_mutex_lock(&XBZRLE.lock);
182}
183
184static void XBZRLE_cache_unlock(void)
185{
186 if (migrate_use_xbzrle())
187 qemu_mutex_unlock(&XBZRLE.lock);
188}
189
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300190int64_t xbzrle_cache_resize(int64_t new_size)
191{
Gongleifd8cec92014-03-04 21:29:21 +0800192 PageCache *new_cache, *cache_to_free;
193
Orit Wassermanc91e6812014-01-30 20:08:34 +0200194 if (new_size < TARGET_PAGE_SIZE) {
195 return -1;
196 }
197
Gongleifd8cec92014-03-04 21:29:21 +0800198 /* no need to lock, the current thread holds qemu big lock */
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300199 if (XBZRLE.cache != NULL) {
Gongleifd8cec92014-03-04 21:29:21 +0800200 /* check XBZRLE.cache again later */
201 if (pow2floor(new_size) == migrate_xbzrle_cache_size()) {
202 return pow2floor(new_size);
203 }
204 new_cache = cache_init(new_size / TARGET_PAGE_SIZE,
205 TARGET_PAGE_SIZE);
206 if (!new_cache) {
207 DPRINTF("Error creating cache\n");
208 return -1;
209 }
210
211 XBZRLE_cache_lock();
212 /* the XBZRLE.cache may have be destroyed, check it again */
213 if (XBZRLE.cache != NULL) {
214 cache_to_free = XBZRLE.cache;
215 XBZRLE.cache = new_cache;
216 } else {
217 cache_to_free = new_cache;
218 }
219 XBZRLE_cache_unlock();
220
221 cache_fini(cache_to_free);
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300222 }
Gongleifd8cec92014-03-04 21:29:21 +0800223
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300224 return pow2floor(new_size);
225}
226
Orit Wasserman004d4c12012-08-06 21:42:56 +0300227/* accounting for migration statistics */
228typedef struct AccountingInfo {
229 uint64_t dup_pages;
Peter Lievenf1c72792013-03-26 10:58:37 +0100230 uint64_t skipped_pages;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300231 uint64_t norm_pages;
232 uint64_t iterations;
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300233 uint64_t xbzrle_bytes;
234 uint64_t xbzrle_pages;
235 uint64_t xbzrle_cache_miss;
236 uint64_t xbzrle_overflows;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300237} AccountingInfo;
238
239static AccountingInfo acct_info;
240
241static void acct_clear(void)
242{
243 memset(&acct_info, 0, sizeof(acct_info));
244}
245
246uint64_t dup_mig_bytes_transferred(void)
247{
248 return acct_info.dup_pages * TARGET_PAGE_SIZE;
249}
250
251uint64_t dup_mig_pages_transferred(void)
252{
253 return acct_info.dup_pages;
254}
255
Peter Lievenf1c72792013-03-26 10:58:37 +0100256uint64_t skipped_mig_bytes_transferred(void)
257{
258 return acct_info.skipped_pages * TARGET_PAGE_SIZE;
259}
260
261uint64_t skipped_mig_pages_transferred(void)
262{
263 return acct_info.skipped_pages;
264}
265
Orit Wasserman004d4c12012-08-06 21:42:56 +0300266uint64_t norm_mig_bytes_transferred(void)
267{
268 return acct_info.norm_pages * TARGET_PAGE_SIZE;
269}
270
271uint64_t norm_mig_pages_transferred(void)
272{
273 return acct_info.norm_pages;
274}
275
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300276uint64_t xbzrle_mig_bytes_transferred(void)
277{
278 return acct_info.xbzrle_bytes;
279}
280
281uint64_t xbzrle_mig_pages_transferred(void)
282{
283 return acct_info.xbzrle_pages;
284}
285
286uint64_t xbzrle_mig_pages_cache_miss(void)
287{
288 return acct_info.xbzrle_cache_miss;
289}
290
291uint64_t xbzrle_mig_pages_overflow(void)
292{
293 return acct_info.xbzrle_overflows;
294}
295
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200296static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
297 int cont, int flag)
Orit Wasserman0c51f432012-06-19 18:43:14 +0300298{
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200299 size_t size;
Orit Wasserman0c51f432012-06-19 18:43:14 +0300300
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200301 qemu_put_be64(f, offset | cont | flag);
302 size = 8;
303
304 if (!cont) {
305 qemu_put_byte(f, strlen(block->idstr));
306 qemu_put_buffer(f, (uint8_t *)block->idstr,
307 strlen(block->idstr));
308 size += 1 + strlen(block->idstr);
309 }
310 return size;
Orit Wasserman0c51f432012-06-19 18:43:14 +0300311}
312
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000313/* This is the last block that we have visited serching for dirty pages
314 */
315static RAMBlock *last_seen_block;
316/* This is the last block from where we have sent data */
317static RAMBlock *last_sent_block;
318static ram_addr_t last_offset;
319static unsigned long *migration_bitmap;
320static uint64_t migration_dirty_pages;
321static uint32_t last_version;
322static bool ram_bulk_stage;
323
324/* Update the xbzrle cache to reflect a page that's been sent as all 0.
325 * The important thing is that a stale (not-yet-0'd) page be replaced
326 * by the new data.
327 * As a bonus, if the page wasn't in the cache it gets added so that
328 * when a small write is made into the 0'd page it gets XBZRLE sent
329 */
330static void xbzrle_cache_zero_page(ram_addr_t current_addr)
331{
332 if (ram_bulk_stage || !migrate_use_xbzrle()) {
333 return;
334 }
335
336 /* We don't care if this fails to allocate a new cache page
337 * as long as it updated an old one */
338 cache_insert(XBZRLE.cache, current_addr, ZERO_TARGET_PAGE);
339}
340
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300341#define ENCODING_FLAG_XBZRLE 0x1
342
343static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
344 ram_addr_t current_addr, RAMBlock *block,
Juan Quinteladd051c72012-08-06 21:42:58 +0300345 ram_addr_t offset, int cont, bool last_stage)
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300346{
347 int encoded_len = 0, bytes_sent = -1;
348 uint8_t *prev_cached_page;
349
350 if (!cache_is_cached(XBZRLE.cache, current_addr)) {
Juan Quinteladd051c72012-08-06 21:42:58 +0300351 if (!last_stage) {
Orit Wasserman89db9982014-01-30 20:08:38 +0200352 if (cache_insert(XBZRLE.cache, current_addr, current_data) == -1) {
353 return -1;
354 }
Juan Quinteladd051c72012-08-06 21:42:58 +0300355 }
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300356 acct_info.xbzrle_cache_miss++;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300357 return -1;
358 }
359
360 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
361
362 /* save current buffer into memory */
363 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE);
364
365 /* XBZRLE encoding (if there is no overflow) */
366 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
367 TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
368 TARGET_PAGE_SIZE);
369 if (encoded_len == 0) {
370 DPRINTF("Skipping unmodified page\n");
371 return 0;
372 } else if (encoded_len == -1) {
373 DPRINTF("Overflow\n");
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300374 acct_info.xbzrle_overflows++;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300375 /* update data in the cache */
376 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE);
377 return -1;
378 }
379
380 /* we need to update the data in the cache, in order to get the same data */
Juan Quinteladd051c72012-08-06 21:42:58 +0300381 if (!last_stage) {
382 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
383 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300384
385 /* Send XBZRLE based compressed page */
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200386 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300387 qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
388 qemu_put_be16(f, encoded_len);
389 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200390 bytes_sent += encoded_len + 1 + 2;
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300391 acct_info.xbzrle_pages++;
392 acct_info.xbzrle_bytes += bytes_sent;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300393
394 return bytes_sent;
395}
396
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200397static inline
398ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
399 ram_addr_t start)
Juan Quintela69268cd2012-07-20 10:36:12 +0200400{
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200401 unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS;
402 unsigned long nr = base + (start >> TARGET_PAGE_BITS);
Michael S. Tsirkin0851c9f2013-08-19 17:26:52 +0300403 uint64_t mr_size = TARGET_PAGE_ALIGN(memory_region_size(mr));
404 unsigned long size = base + (mr_size >> TARGET_PAGE_BITS);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200405
Peter Lieven70c86522013-03-26 10:58:38 +0100406 unsigned long next;
407
408 if (ram_bulk_stage && nr > base) {
409 next = nr + 1;
410 } else {
411 next = find_next_bit(migration_bitmap, size, nr);
412 }
Juan Quintela69268cd2012-07-20 10:36:12 +0200413
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200414 if (next < size) {
415 clear_bit(next, migration_bitmap);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200416 migration_dirty_pages--;
Juan Quintela69268cd2012-07-20 10:36:12 +0200417 }
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200418 return (next - base) << TARGET_PAGE_BITS;
Juan Quintela69268cd2012-07-20 10:36:12 +0200419}
420
Juan Quintela791fa2a2013-11-05 16:47:20 +0100421static inline bool migration_bitmap_set_dirty(ram_addr_t addr)
Juan Quintelae44d26c2012-07-20 10:16:08 +0200422{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200423 bool ret;
Juan Quintela791fa2a2013-11-05 16:47:20 +0100424 int nr = addr >> TARGET_PAGE_BITS;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200425
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200426 ret = test_and_set_bit(nr, migration_bitmap);
427
428 if (!ret) {
429 migration_dirty_pages++;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200430 }
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200431 return ret;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200432}
433
Juan Quintela791fa2a2013-11-05 16:47:20 +0100434static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length)
435{
436 ram_addr_t addr;
Juan Quintelaaa8dc042013-11-06 11:33:05 +0100437 unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
Juan Quintela791fa2a2013-11-05 16:47:20 +0100438
Juan Quintelaaa8dc042013-11-06 11:33:05 +0100439 /* start address is aligned at the start of a word? */
440 if (((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) {
441 int k;
442 int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS);
443 unsigned long *src = ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION];
444
445 for (k = page; k < page + nr; k++) {
446 if (src[k]) {
447 unsigned long new_dirty;
448 new_dirty = ~migration_bitmap[k];
449 migration_bitmap[k] |= src[k];
450 new_dirty &= src[k];
451 migration_dirty_pages += ctpopl(new_dirty);
452 src[k] = 0;
453 }
454 }
455 } else {
456 for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) {
457 if (cpu_physical_memory_get_dirty(start + addr,
458 TARGET_PAGE_SIZE,
459 DIRTY_MEMORY_MIGRATION)) {
460 cpu_physical_memory_reset_dirty(start + addr,
461 TARGET_PAGE_SIZE,
462 DIRTY_MEMORY_MIGRATION);
463 migration_bitmap_set_dirty(start + addr);
464 }
Juan Quintela791fa2a2013-11-05 16:47:20 +0100465 }
466 }
467}
468
469
Paolo Bonzini32c835b2013-02-22 17:36:27 +0100470/* Needs iothread lock! */
471
Juan Quinteladd2df732012-07-20 10:52:51 +0200472static void migration_bitmap_sync(void)
473{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200474 RAMBlock *block;
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200475 uint64_t num_dirty_pages_init = migration_dirty_pages;
Juan Quintela8d017192012-08-13 12:31:25 +0200476 MigrationState *s = migrate_get_current();
477 static int64_t start_time;
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600478 static int64_t bytes_xfer_prev;
Juan Quintela8d017192012-08-13 12:31:25 +0200479 static int64_t num_dirty_pages_period;
480 int64_t end_time;
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600481 int64_t bytes_xfer_now;
482
483 if (!bytes_xfer_prev) {
484 bytes_xfer_prev = ram_bytes_transferred();
485 }
Juan Quintela8d017192012-08-13 12:31:25 +0200486
487 if (!start_time) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100488 start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintela8d017192012-08-13 12:31:25 +0200489 }
Juan Quintela3c121932012-09-04 13:08:57 +0200490
491 trace_migration_bitmap_sync_start();
Paolo Bonzini1d671362013-04-24 10:46:55 +0200492 address_space_sync_dirty_bitmap(&address_space_memory);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200493
Paolo Bonzinia3161032012-11-14 15:54:48 +0100494 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
Juan Quintela791fa2a2013-11-05 16:47:20 +0100495 migration_bitmap_sync_range(block->mr->ram_addr, block->length);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200496 }
497 trace_migration_bitmap_sync_end(migration_dirty_pages
Juan Quintela3c121932012-09-04 13:08:57 +0200498 - num_dirty_pages_init);
Juan Quintela8d017192012-08-13 12:31:25 +0200499 num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
Alex Blighbc72ad62013-08-21 16:03:08 +0100500 end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
Juan Quintela8d017192012-08-13 12:31:25 +0200501
502 /* more than 1 second = 1000 millisecons */
503 if (end_time > start_time + 1000) {
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600504 if (migrate_auto_converge()) {
505 /* The following detection logic can be refined later. For now:
506 Check to see if the dirtied bytes is 50% more than the approx.
507 amount of bytes that just got transferred since the last time we
508 were in this routine. If that happens >N times (for now N==4)
509 we turn on the throttle down logic */
510 bytes_xfer_now = ram_bytes_transferred();
511 if (s->dirty_pages_rate &&
512 (num_dirty_pages_period * TARGET_PAGE_SIZE >
513 (bytes_xfer_now - bytes_xfer_prev)/2) &&
514 (dirty_rate_high_cnt++ > 4)) {
515 trace_migration_throttle();
516 mig_throttle_on = true;
517 dirty_rate_high_cnt = 0;
518 }
519 bytes_xfer_prev = bytes_xfer_now;
520 } else {
521 mig_throttle_on = false;
522 }
Juan Quintela8d017192012-08-13 12:31:25 +0200523 s->dirty_pages_rate = num_dirty_pages_period * 1000
524 / (end_time - start_time);
Juan Quintela90f8ae72013-02-01 13:22:37 +0100525 s->dirty_bytes_rate = s->dirty_pages_rate * TARGET_PAGE_SIZE;
Juan Quintela8d017192012-08-13 12:31:25 +0200526 start_time = end_time;
527 num_dirty_pages_period = 0;
528 }
Juan Quinteladd2df732012-07-20 10:52:51 +0200529}
530
Orit Wasserman6c779f22012-07-10 12:37:13 +0300531/*
532 * ram_save_block: Writes a page of memory to the stream f
533 *
Juan Quintelab823cea2012-12-10 13:27:50 +0100534 * Returns: The number of bytes written.
535 * 0 means no dirty pages
Orit Wasserman6c779f22012-07-10 12:37:13 +0300536 */
537
Juan Quinteladd051c72012-08-06 21:42:58 +0300538static int ram_save_block(QEMUFile *f, bool last_stage)
Blue Swirlad960902010-03-29 19:23:52 +0000539{
Juan Quintelab23a9a52012-10-17 20:08:04 +0200540 RAMBlock *block = last_seen_block;
Alex Williamsone44359c2010-06-25 11:09:57 -0600541 ram_addr_t offset = last_offset;
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200542 bool complete_round = false;
Juan Quintelab823cea2012-12-10 13:27:50 +0100543 int bytes_sent = 0;
Avi Kivity71c510e2011-12-21 13:11:22 +0200544 MemoryRegion *mr;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300545 ram_addr_t current_addr;
Blue Swirlad960902010-03-29 19:23:52 +0000546
Alex Williamsone44359c2010-06-25 11:09:57 -0600547 if (!block)
Paolo Bonzinia3161032012-11-14 15:54:48 +0100548 block = QTAILQ_FIRST(&ram_list.blocks);
Alex Williamsone44359c2010-06-25 11:09:57 -0600549
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200550 while (true) {
Avi Kivity71c510e2011-12-21 13:11:22 +0200551 mr = block->mr;
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200552 offset = migration_bitmap_find_and_reset_dirty(mr, offset);
553 if (complete_round && block == last_seen_block &&
554 offset >= last_offset) {
555 break;
556 }
557 if (offset >= block->length) {
558 offset = 0;
559 block = QTAILQ_NEXT(block, next);
560 if (!block) {
561 block = QTAILQ_FIRST(&ram_list.blocks);
562 complete_round = true;
Peter Lieven78d07ae2013-03-26 10:58:36 +0100563 ram_bulk_stage = false;
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200564 }
565 } else {
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400566 int ret;
Blue Swirlad960902010-03-29 19:23:52 +0000567 uint8_t *p;
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000568 bool send_async = true;
Juan Quintela5f718a12012-10-17 20:10:55 +0200569 int cont = (block == last_sent_block) ?
Juan Quintelab23a9a52012-10-17 20:08:04 +0200570 RAM_SAVE_FLAG_CONTINUE : 0;
Blue Swirlad960902010-03-29 19:23:52 +0000571
Avi Kivity71c510e2011-12-21 13:11:22 +0200572 p = memory_region_get_ram_ptr(mr) + offset;
Blue Swirlad960902010-03-29 19:23:52 +0000573
Juan Quintelab823cea2012-12-10 13:27:50 +0100574 /* In doubt sent page as normal */
575 bytes_sent = -1;
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400576 ret = ram_control_save_page(f, block->offset,
577 offset, TARGET_PAGE_SIZE, &bytes_sent);
578
Gongleifd8cec92014-03-04 21:29:21 +0800579 XBZRLE_cache_lock();
580
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000581 current_addr = block->offset + offset;
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400582 if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
583 if (ret != RAM_SAVE_CONTROL_DELAYED) {
584 if (bytes_sent > 0) {
585 acct_info.norm_pages++;
586 } else if (bytes_sent == 0) {
587 acct_info.dup_pages++;
588 }
589 }
Isaku Yamahatadc3c26a2013-09-21 01:23:36 +0900590 } else if (is_zero_range(p, TARGET_PAGE_SIZE)) {
Orit Wasserman004d4c12012-08-06 21:42:56 +0300591 acct_info.dup_pages++;
Peter Lieven9ef051e2013-06-10 12:14:19 +0200592 bytes_sent = save_block_hdr(f, block, offset, cont,
593 RAM_SAVE_FLAG_COMPRESS);
594 qemu_put_byte(f, 0);
595 bytes_sent++;
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000596 /* Must let xbzrle know, otherwise a previous (now 0'd) cached
597 * page would be stale
598 */
599 xbzrle_cache_zero_page(current_addr);
Peter Lieven5cc11c42013-03-26 10:58:39 +0100600 } else if (!ram_bulk_stage && migrate_use_xbzrle()) {
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300601 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
Juan Quinteladd051c72012-08-06 21:42:58 +0300602 offset, cont, last_stage);
603 if (!last_stage) {
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000604 /* We must send exactly what's in the xbzrle cache
605 * even if the page wasn't xbzrle compressed, so that
606 * it's right next time.
607 */
Juan Quinteladd051c72012-08-06 21:42:58 +0300608 p = get_cached_data(XBZRLE.cache, current_addr);
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000609
610 /* Can't send this cached data async, since the cache page
611 * might get updated before it gets to the wire
612 */
613 send_async = false;
Juan Quinteladd051c72012-08-06 21:42:58 +0300614 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300615 }
616
Juan Quintelab823cea2012-12-10 13:27:50 +0100617 /* XBZRLE overflow or normal page */
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300618 if (bytes_sent == -1) {
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200619 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
Dr. David Alan Gilbert6d3cb1f2014-02-13 19:44:45 +0000620 if (send_async) {
621 qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE);
622 } else {
623 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
624 }
Juan Quintela3f7d7b02012-10-18 13:56:35 +0200625 bytes_sent += TARGET_PAGE_SIZE;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300626 acct_info.norm_pages++;
Blue Swirlad960902010-03-29 19:23:52 +0000627 }
628
Gongleifd8cec92014-03-04 21:29:21 +0800629 XBZRLE_cache_unlock();
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300630 /* if page is unmodified, continue to the next */
Juan Quintelab823cea2012-12-10 13:27:50 +0100631 if (bytes_sent > 0) {
Juan Quintela5f718a12012-10-17 20:10:55 +0200632 last_sent_block = block;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300633 break;
634 }
Blue Swirlad960902010-03-29 19:23:52 +0000635 }
Juan Quintela4c8ae0f2012-10-18 00:00:59 +0200636 }
Juan Quintelab23a9a52012-10-17 20:08:04 +0200637 last_seen_block = block;
Alex Williamsone44359c2010-06-25 11:09:57 -0600638 last_offset = offset;
Blue Swirlad960902010-03-29 19:23:52 +0000639
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200640 return bytes_sent;
Blue Swirlad960902010-03-29 19:23:52 +0000641}
642
643static uint64_t bytes_transferred;
644
Michael R. Hines2b0ce072013-06-25 21:35:28 -0400645void acct_update_position(QEMUFile *f, size_t size, bool zero)
646{
647 uint64_t pages = size / TARGET_PAGE_SIZE;
648 if (zero) {
649 acct_info.dup_pages += pages;
650 } else {
651 acct_info.norm_pages += pages;
652 bytes_transferred += size;
653 qemu_update_position(f, size);
654 }
655}
656
Blue Swirlad960902010-03-29 19:23:52 +0000657static ram_addr_t ram_save_remaining(void)
658{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200659 return migration_dirty_pages;
Blue Swirlad960902010-03-29 19:23:52 +0000660}
661
662uint64_t ram_bytes_remaining(void)
663{
664 return ram_save_remaining() * TARGET_PAGE_SIZE;
665}
666
667uint64_t ram_bytes_transferred(void)
668{
669 return bytes_transferred;
670}
671
672uint64_t ram_bytes_total(void)
673{
Alex Williamsond17b5282010-06-25 11:08:38 -0600674 RAMBlock *block;
675 uint64_t total = 0;
676
Paolo Bonzinia3161032012-11-14 15:54:48 +0100677 QTAILQ_FOREACH(block, &ram_list.blocks, next)
Alex Williamsond17b5282010-06-25 11:08:38 -0600678 total += block->length;
679
680 return total;
Blue Swirlad960902010-03-29 19:23:52 +0000681}
682
Gonglei (Arei)905f26f2014-01-30 20:08:35 +0200683void free_xbzrle_decoded_buf(void)
684{
685 g_free(xbzrle_decoded_buf);
686 xbzrle_decoded_buf = NULL;
687}
688
Orit Wasserman8e21cd32012-06-19 18:43:17 +0300689static void migration_end(void)
690{
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100691 if (migration_bitmap) {
692 memory_global_dirty_log_stop();
693 g_free(migration_bitmap);
694 migration_bitmap = NULL;
695 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300696
Gongleifd8cec92014-03-04 21:29:21 +0800697 XBZRLE_cache_lock();
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100698 if (XBZRLE.cache) {
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300699 cache_fini(XBZRLE.cache);
700 g_free(XBZRLE.cache);
701 g_free(XBZRLE.encoded_buf);
702 g_free(XBZRLE.current_buf);
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300703 XBZRLE.cache = NULL;
Orit Wassermanf6c64832014-01-30 20:08:33 +0200704 XBZRLE.encoded_buf = NULL;
705 XBZRLE.current_buf = NULL;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300706 }
Gongleifd8cec92014-03-04 21:29:21 +0800707 XBZRLE_cache_unlock();
Orit Wasserman8e21cd32012-06-19 18:43:17 +0300708}
709
Juan Quintela9b5bfab2012-06-26 19:26:41 +0200710static void ram_migration_cancel(void *opaque)
711{
712 migration_end();
713}
714
Juan Quintela5a170772012-07-17 17:02:24 +0200715static void reset_ram_globals(void)
716{
Juan Quintelab23a9a52012-10-17 20:08:04 +0200717 last_seen_block = NULL;
Juan Quintela5f718a12012-10-17 20:10:55 +0200718 last_sent_block = NULL;
Juan Quintela5a170772012-07-17 17:02:24 +0200719 last_offset = 0;
Umesh Deshpandef798b072011-08-18 11:41:17 -0700720 last_version = ram_list.version;
Peter Lieven78d07ae2013-03-26 10:58:36 +0100721 ram_bulk_stage = true;
Juan Quintela5a170772012-07-17 17:02:24 +0200722}
723
Juan Quintela4508bd92012-05-22 16:27:59 +0200724#define MAX_WAIT 50 /* ms, half buffered_file limit */
725
Juan Quintelad1315aa2012-06-28 15:11:57 +0200726static int ram_save_setup(QEMUFile *f, void *opaque)
Blue Swirlad960902010-03-29 19:23:52 +0000727{
Juan Quintelad1315aa2012-06-28 15:11:57 +0200728 RAMBlock *block;
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200729 int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
730
731 migration_bitmap = bitmap_new(ram_pages);
David Gibson7ec81e52012-12-04 11:38:38 +1100732 bitmap_set(migration_bitmap, 0, ram_pages);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200733 migration_dirty_pages = ram_pages;
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600734 mig_throttle_on = false;
735 dirty_rate_high_cnt = 0;
Blue Swirlad960902010-03-29 19:23:52 +0000736
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300737 if (migrate_use_xbzrle()) {
Gongleifd8cec92014-03-04 21:29:21 +0800738 qemu_mutex_lock_iothread();
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300739 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
740 TARGET_PAGE_SIZE,
741 TARGET_PAGE_SIZE);
742 if (!XBZRLE.cache) {
Gongleifd8cec92014-03-04 21:29:21 +0800743 qemu_mutex_unlock_iothread();
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300744 DPRINTF("Error creating cache\n");
745 return -1;
746 }
Gongleifd8cec92014-03-04 21:29:21 +0800747 qemu_mutex_init(&XBZRLE.lock);
748 qemu_mutex_unlock_iothread();
Orit Wassermana17b2fd2014-01-30 20:08:37 +0200749
750 /* We prefer not to abort if there is no memory */
751 XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);
752 if (!XBZRLE.encoded_buf) {
753 DPRINTF("Error allocating encoded_buf\n");
754 return -1;
755 }
756
757 XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);
758 if (!XBZRLE.current_buf) {
759 DPRINTF("Error allocating current_buf\n");
760 g_free(XBZRLE.encoded_buf);
761 XBZRLE.encoded_buf = NULL;
762 return -1;
763 }
764
Orit Wasserman004d4c12012-08-06 21:42:56 +0300765 acct_clear();
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300766 }
767
Paolo Bonzini9b095032013-02-22 17:36:28 +0100768 qemu_mutex_lock_iothread();
769 qemu_mutex_lock_ramlist();
770 bytes_transferred = 0;
771 reset_ram_globals();
772
Juan Quintelad1315aa2012-06-28 15:11:57 +0200773 memory_global_dirty_log_start();
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200774 migration_bitmap_sync();
Paolo Bonzini9b095032013-02-22 17:36:28 +0100775 qemu_mutex_unlock_iothread();
Juan Quintelad1315aa2012-06-28 15:11:57 +0200776
777 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
778
Paolo Bonzinia3161032012-11-14 15:54:48 +0100779 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
Juan Quintelad1315aa2012-06-28 15:11:57 +0200780 qemu_put_byte(f, strlen(block->idstr));
781 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
782 qemu_put_be64(f, block->length);
783 }
784
Umesh Deshpandeb2a86582011-08-17 00:01:33 -0700785 qemu_mutex_unlock_ramlist();
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400786
787 ram_control_before_iterate(f, RAM_CONTROL_SETUP);
788 ram_control_after_iterate(f, RAM_CONTROL_SETUP);
789
Juan Quintelad1315aa2012-06-28 15:11:57 +0200790 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
791
792 return 0;
793}
794
Juan Quintela16310a32012-06-28 15:31:37 +0200795static int ram_save_iterate(QEMUFile *f, void *opaque)
Juan Quintelad1315aa2012-06-28 15:11:57 +0200796{
Blue Swirlad960902010-03-29 19:23:52 +0000797 int ret;
798 int i;
Juan Quintelae4ed1542012-09-21 11:18:18 +0200799 int64_t t0;
Juan Quintelab823cea2012-12-10 13:27:50 +0100800 int total_sent = 0;
Blue Swirlad960902010-03-29 19:23:52 +0000801
Umesh Deshpandeb2a86582011-08-17 00:01:33 -0700802 qemu_mutex_lock_ramlist();
803
Umesh Deshpandef798b072011-08-18 11:41:17 -0700804 if (ram_list.version != last_version) {
805 reset_ram_globals();
806 }
807
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400808 ram_control_before_iterate(f, RAM_CONTROL_ROUND);
809
Alex Blighbc72ad62013-08-21 16:03:08 +0100810 t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Juan Quintela4508bd92012-05-22 16:27:59 +0200811 i = 0;
Juan Quintela29757252011-10-19 15:22:18 +0200812 while ((ret = qemu_file_rate_limit(f)) == 0) {
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200813 int bytes_sent;
Blue Swirlad960902010-03-29 19:23:52 +0000814
Juan Quinteladd051c72012-08-06 21:42:58 +0300815 bytes_sent = ram_save_block(f, false);
Orit Wasserman6c779f22012-07-10 12:37:13 +0300816 /* no more blocks to sent */
Juan Quintelab823cea2012-12-10 13:27:50 +0100817 if (bytes_sent == 0) {
Blue Swirlad960902010-03-29 19:23:52 +0000818 break;
819 }
Juan Quintelab823cea2012-12-10 13:27:50 +0100820 total_sent += bytes_sent;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300821 acct_info.iterations++;
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -0600822 check_guest_throttling();
Juan Quintela4508bd92012-05-22 16:27:59 +0200823 /* we want to check in the 1st loop, just in case it was the 1st time
824 and we had to sync the dirty bitmap.
825 qemu_get_clock_ns() is a bit expensive, so we only check each some
826 iterations
827 */
828 if ((i & 63) == 0) {
Alex Blighbc72ad62013-08-21 16:03:08 +0100829 uint64_t t1 = (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - t0) / 1000000;
Juan Quintela4508bd92012-05-22 16:27:59 +0200830 if (t1 > MAX_WAIT) {
Igor Mitsyankoef37a692012-09-05 13:04:56 +0400831 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
Juan Quintela4508bd92012-05-22 16:27:59 +0200832 t1, i);
833 break;
834 }
835 }
836 i++;
Blue Swirlad960902010-03-29 19:23:52 +0000837 }
838
Paolo Bonzinifb3409d2012-12-20 11:25:45 +0100839 qemu_mutex_unlock_ramlist();
840
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400841 /*
842 * Must occur before EOS (or any QEMUFile operation)
843 * because of RDMA protocol.
844 */
845 ram_control_after_iterate(f, RAM_CONTROL_ROUND);
846
Lei Li6cd0bed2013-09-04 17:02:36 +0800847 bytes_transferred += total_sent;
848
849 /*
850 * Do not count these 8 bytes into total_sent, so that we can
851 * return 0 if no page had been dirtied.
852 */
853 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
854 bytes_transferred += 8;
855
856 ret = qemu_file_get_error(f);
Juan Quintela29757252011-10-19 15:22:18 +0200857 if (ret < 0) {
858 return ret;
859 }
860
Juan Quintelab823cea2012-12-10 13:27:50 +0100861 return total_sent;
Blue Swirlad960902010-03-29 19:23:52 +0000862}
863
Juan Quintela16310a32012-06-28 15:31:37 +0200864static int ram_save_complete(QEMUFile *f, void *opaque)
865{
Umesh Deshpandeb2a86582011-08-17 00:01:33 -0700866 qemu_mutex_lock_ramlist();
Paolo Bonzini9c339482012-12-20 11:26:04 +0100867 migration_bitmap_sync();
Umesh Deshpandeb2a86582011-08-17 00:01:33 -0700868
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400869 ram_control_before_iterate(f, RAM_CONTROL_FINISH);
870
Juan Quintela16310a32012-06-28 15:31:37 +0200871 /* try transferring iterative blocks of memory */
872
873 /* flush all remaining blocks regardless of rate limiting */
Orit Wasserman6c779f22012-07-10 12:37:13 +0300874 while (true) {
875 int bytes_sent;
876
Juan Quinteladd051c72012-08-06 21:42:58 +0300877 bytes_sent = ram_save_block(f, true);
Orit Wasserman6c779f22012-07-10 12:37:13 +0300878 /* no more blocks to sent */
Juan Quintelab823cea2012-12-10 13:27:50 +0100879 if (bytes_sent == 0) {
Orit Wasserman6c779f22012-07-10 12:37:13 +0300880 break;
881 }
Juan Quintela16310a32012-06-28 15:31:37 +0200882 bytes_transferred += bytes_sent;
883 }
Michael R. Hines0033b8b2013-07-22 10:01:55 -0400884
885 ram_control_after_iterate(f, RAM_CONTROL_FINISH);
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100886 migration_end();
Juan Quintela16310a32012-06-28 15:31:37 +0200887
Umesh Deshpandeb2a86582011-08-17 00:01:33 -0700888 qemu_mutex_unlock_ramlist();
Blue Swirlad960902010-03-29 19:23:52 +0000889 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
890
Alex Williamsona55bbe32010-06-25 11:10:05 -0600891 return 0;
892}
893
Juan Quintelae4ed1542012-09-21 11:18:18 +0200894static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size)
895{
896 uint64_t remaining_size;
897
898 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
899
900 if (remaining_size < max_size) {
Paolo Bonzini32c835b2013-02-22 17:36:27 +0100901 qemu_mutex_lock_iothread();
Juan Quintelae4ed1542012-09-21 11:18:18 +0200902 migration_bitmap_sync();
Paolo Bonzini32c835b2013-02-22 17:36:27 +0100903 qemu_mutex_unlock_iothread();
Juan Quintelae4ed1542012-09-21 11:18:18 +0200904 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
905 }
906 return remaining_size;
907}
908
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300909static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
910{
911 int ret, rc = 0;
912 unsigned int xh_len;
913 int xh_flags;
914
Gonglei (Arei)905f26f2014-01-30 20:08:35 +0200915 if (!xbzrle_decoded_buf) {
916 xbzrle_decoded_buf = g_malloc(TARGET_PAGE_SIZE);
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300917 }
918
919 /* extract RLE header */
920 xh_flags = qemu_get_byte(f);
921 xh_len = qemu_get_be16(f);
922
923 if (xh_flags != ENCODING_FLAG_XBZRLE) {
924 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
925 return -1;
926 }
927
928 if (xh_len > TARGET_PAGE_SIZE) {
929 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
930 return -1;
931 }
932 /* load data and decode */
Gonglei (Arei)905f26f2014-01-30 20:08:35 +0200933 qemu_get_buffer(f, xbzrle_decoded_buf, xh_len);
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300934
935 /* decode RLE */
Gonglei (Arei)905f26f2014-01-30 20:08:35 +0200936 ret = xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host,
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300937 TARGET_PAGE_SIZE);
938 if (ret == -1) {
939 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
940 rc = -1;
941 } else if (ret > TARGET_PAGE_SIZE) {
942 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
943 ret, TARGET_PAGE_SIZE);
944 abort();
945 }
946
947 return rc;
948}
949
Alex Williamsona55bbe32010-06-25 11:10:05 -0600950static inline void *host_from_stream_offset(QEMUFile *f,
951 ram_addr_t offset,
952 int flags)
953{
954 static RAMBlock *block = NULL;
955 char id[256];
956 uint8_t len;
957
958 if (flags & RAM_SAVE_FLAG_CONTINUE) {
959 if (!block) {
960 fprintf(stderr, "Ack, bad migration stream!\n");
961 return NULL;
962 }
963
Avi Kivitydc94a7e2011-12-21 13:54:33 +0200964 return memory_region_get_ram_ptr(block->mr) + offset;
Alex Williamsona55bbe32010-06-25 11:10:05 -0600965 }
966
967 len = qemu_get_byte(f);
968 qemu_get_buffer(f, (uint8_t *)id, len);
969 id[len] = 0;
970
Paolo Bonzinia3161032012-11-14 15:54:48 +0100971 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
Alex Williamsona55bbe32010-06-25 11:10:05 -0600972 if (!strncmp(id, block->idstr, sizeof(id)))
Avi Kivitydc94a7e2011-12-21 13:54:33 +0200973 return memory_region_get_ram_ptr(block->mr) + offset;
Alex Williamsona55bbe32010-06-25 11:10:05 -0600974 }
975
976 fprintf(stderr, "Can't find block %s!\n", id);
977 return NULL;
978}
979
Michael R. Hines44c3b582013-07-22 10:01:53 -0400980/*
981 * If a page (or a whole RDMA chunk) has been
982 * determined to be zero, then zap it.
983 */
984void ram_handle_compressed(void *host, uint8_t ch, uint64_t size)
985{
Isaku Yamahatad613a562013-09-21 01:23:37 +0900986 if (ch != 0 || !is_zero_range(host, size)) {
Michael R. Hines44c3b582013-07-22 10:01:53 -0400987 memset(host, ch, size);
Michael R. Hines44c3b582013-07-22 10:01:53 -0400988 }
989}
990
Juan Quintela7908c782012-06-26 18:46:10 +0200991static int ram_load(QEMUFile *f, void *opaque, int version_id)
Blue Swirlad960902010-03-29 19:23:52 +0000992{
993 ram_addr_t addr;
Orit Wasserman3a697f62012-06-19 18:43:15 +0300994 int flags, ret = 0;
Juan Quintela42802d42011-10-05 01:14:46 +0200995 int error;
Orit Wasserman3a697f62012-06-19 18:43:15 +0300996 static uint64_t seq_iter;
997
998 seq_iter++;
Blue Swirlad960902010-03-29 19:23:52 +0000999
Avi Kivityf09f2182011-12-21 13:37:56 +02001000 if (version_id < 4 || version_id > 4) {
Blue Swirlad960902010-03-29 19:23:52 +00001001 return -EINVAL;
1002 }
1003
1004 do {
1005 addr = qemu_get_be64(f);
1006
1007 flags = addr & ~TARGET_PAGE_MASK;
1008 addr &= TARGET_PAGE_MASK;
1009
1010 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
Avi Kivityf09f2182011-12-21 13:37:56 +02001011 if (version_id == 4) {
Alex Williamson97ab12d2010-06-25 11:09:50 -06001012 /* Synchronize RAM block list */
1013 char id[256];
1014 ram_addr_t length;
1015 ram_addr_t total_ram_bytes = addr;
1016
1017 while (total_ram_bytes) {
1018 RAMBlock *block;
1019 uint8_t len;
1020
1021 len = qemu_get_byte(f);
1022 qemu_get_buffer(f, (uint8_t *)id, len);
1023 id[len] = 0;
1024 length = qemu_get_be64(f);
1025
Paolo Bonzinia3161032012-11-14 15:54:48 +01001026 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
Alex Williamson97ab12d2010-06-25 11:09:50 -06001027 if (!strncmp(id, block->idstr, sizeof(id))) {
Orit Wasserman3a697f62012-06-19 18:43:15 +03001028 if (block->length != length) {
Stefan Weil6bedfe92013-06-27 21:00:06 +02001029 fprintf(stderr,
1030 "Length mismatch: %s: " RAM_ADDR_FMT
1031 " in != " RAM_ADDR_FMT "\n", id, length,
Alon Levy87d2f822013-05-12 14:16:28 +03001032 block->length);
Orit Wasserman3a697f62012-06-19 18:43:15 +03001033 ret = -EINVAL;
1034 goto done;
1035 }
Alex Williamson97ab12d2010-06-25 11:09:50 -06001036 break;
1037 }
1038 }
1039
1040 if (!block) {
Alex Williamsonfb787f82010-07-02 11:13:29 -06001041 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
1042 "accept migration\n", id);
Orit Wasserman3a697f62012-06-19 18:43:15 +03001043 ret = -EINVAL;
1044 goto done;
Alex Williamson97ab12d2010-06-25 11:09:50 -06001045 }
1046
1047 total_ram_bytes -= length;
1048 }
Blue Swirlad960902010-03-29 19:23:52 +00001049 }
1050 }
1051
1052 if (flags & RAM_SAVE_FLAG_COMPRESS) {
Alex Williamson97ab12d2010-06-25 11:09:50 -06001053 void *host;
1054 uint8_t ch;
1055
Avi Kivityf09f2182011-12-21 13:37:56 +02001056 host = host_from_stream_offset(f, addr, flags);
Michael S. Tsirkin492fb992010-10-17 20:43:40 +02001057 if (!host) {
1058 return -EINVAL;
1059 }
Alex Williamson97ab12d2010-06-25 11:09:50 -06001060
Alex Williamson97ab12d2010-06-25 11:09:50 -06001061 ch = qemu_get_byte(f);
Michael R. Hines44c3b582013-07-22 10:01:53 -04001062 ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);
Blue Swirlad960902010-03-29 19:23:52 +00001063 } else if (flags & RAM_SAVE_FLAG_PAGE) {
Alex Williamson97ab12d2010-06-25 11:09:50 -06001064 void *host;
1065
Avi Kivityf09f2182011-12-21 13:37:56 +02001066 host = host_from_stream_offset(f, addr, flags);
Orit Wasserman0ff1f9f2012-06-19 11:51:37 +03001067 if (!host) {
1068 return -EINVAL;
1069 }
Alex Williamson97ab12d2010-06-25 11:09:50 -06001070
Alex Williamson97ab12d2010-06-25 11:09:50 -06001071 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
Orit Wasserman17ad9b32012-08-06 21:42:53 +03001072 } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
Orit Wasserman17ad9b32012-08-06 21:42:53 +03001073 void *host = host_from_stream_offset(f, addr, flags);
1074 if (!host) {
1075 return -EINVAL;
1076 }
1077
1078 if (load_xbzrle(f, addr, host) < 0) {
1079 ret = -EINVAL;
1080 goto done;
1081 }
Michael R. Hines0033b8b2013-07-22 10:01:55 -04001082 } else if (flags & RAM_SAVE_FLAG_HOOK) {
1083 ram_control_load_hook(f, flags);
Blue Swirlad960902010-03-29 19:23:52 +00001084 }
Juan Quintela42802d42011-10-05 01:14:46 +02001085 error = qemu_file_get_error(f);
1086 if (error) {
Orit Wasserman3a697f62012-06-19 18:43:15 +03001087 ret = error;
1088 goto done;
Blue Swirlad960902010-03-29 19:23:52 +00001089 }
1090 } while (!(flags & RAM_SAVE_FLAG_EOS));
1091
Orit Wasserman3a697f62012-06-19 18:43:15 +03001092done:
Igor Mitsyankoef37a692012-09-05 13:04:56 +04001093 DPRINTF("Completed load of VM with exit code %d seq iteration "
1094 "%" PRIu64 "\n", ret, seq_iter);
Orit Wasserman3a697f62012-06-19 18:43:15 +03001095 return ret;
Blue Swirlad960902010-03-29 19:23:52 +00001096}
1097
Juan Quintela7908c782012-06-26 18:46:10 +02001098SaveVMHandlers savevm_ram_handlers = {
Juan Quintelad1315aa2012-06-28 15:11:57 +02001099 .save_live_setup = ram_save_setup,
Juan Quintela16310a32012-06-28 15:31:37 +02001100 .save_live_iterate = ram_save_iterate,
1101 .save_live_complete = ram_save_complete,
Juan Quintelae4ed1542012-09-21 11:18:18 +02001102 .save_live_pending = ram_save_pending,
Juan Quintela7908c782012-06-26 18:46:10 +02001103 .load_state = ram_load,
Juan Quintela9b5bfab2012-06-26 19:26:41 +02001104 .cancel = ram_migration_cancel,
Juan Quintela7908c782012-06-26 18:46:10 +02001105};
1106
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001107struct soundhw {
1108 const char *name;
1109 const char *descr;
1110 int enabled;
1111 int isa;
1112 union {
Hervé Poussineau4a0f0312011-12-15 22:10:01 +01001113 int (*init_isa) (ISABus *bus);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001114 int (*init_pci) (PCIBus *bus);
1115 } init;
1116};
1117
Paolo Bonzini36cd6f62013-04-18 18:43:58 +02001118static struct soundhw soundhw[9];
1119static int soundhw_count;
Blue Swirlad960902010-03-29 19:23:52 +00001120
Paolo Bonzini36cd6f62013-04-18 18:43:58 +02001121void isa_register_soundhw(const char *name, const char *descr,
1122 int (*init_isa)(ISABus *bus))
1123{
1124 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
1125 soundhw[soundhw_count].name = name;
1126 soundhw[soundhw_count].descr = descr;
1127 soundhw[soundhw_count].isa = 1;
1128 soundhw[soundhw_count].init.init_isa = init_isa;
1129 soundhw_count++;
1130}
Blue Swirlad960902010-03-29 19:23:52 +00001131
Paolo Bonzini36cd6f62013-04-18 18:43:58 +02001132void pci_register_soundhw(const char *name, const char *descr,
1133 int (*init_pci)(PCIBus *bus))
1134{
1135 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
1136 soundhw[soundhw_count].name = name;
1137 soundhw[soundhw_count].descr = descr;
1138 soundhw[soundhw_count].isa = 0;
1139 soundhw[soundhw_count].init.init_pci = init_pci;
1140 soundhw_count++;
1141}
Blue Swirlad960902010-03-29 19:23:52 +00001142
1143void select_soundhw(const char *optarg)
1144{
1145 struct soundhw *c;
1146
Peter Maydellc8057f92012-08-02 13:45:54 +01001147 if (is_help_option(optarg)) {
Blue Swirlad960902010-03-29 19:23:52 +00001148 show_valid_cards:
1149
Paolo Bonzini36cd6f62013-04-18 18:43:58 +02001150 if (soundhw_count) {
1151 printf("Valid sound card names (comma separated):\n");
1152 for (c = soundhw; c->name; ++c) {
1153 printf ("%-11s %s\n", c->name, c->descr);
1154 }
1155 printf("\n-soundhw all will enable all of the above\n");
1156 } else {
1157 printf("Machine has no user-selectable audio hardware "
1158 "(it may or may not have always-present audio hardware).\n");
Blue Swirlad960902010-03-29 19:23:52 +00001159 }
Peter Maydellc8057f92012-08-02 13:45:54 +01001160 exit(!is_help_option(optarg));
Blue Swirlad960902010-03-29 19:23:52 +00001161 }
1162 else {
1163 size_t l;
1164 const char *p;
1165 char *e;
1166 int bad_card = 0;
1167
1168 if (!strcmp(optarg, "all")) {
1169 for (c = soundhw; c->name; ++c) {
1170 c->enabled = 1;
1171 }
1172 return;
1173 }
1174
1175 p = optarg;
1176 while (*p) {
1177 e = strchr(p, ',');
1178 l = !e ? strlen(p) : (size_t) (e - p);
1179
1180 for (c = soundhw; c->name; ++c) {
1181 if (!strncmp(c->name, p, l) && !c->name[l]) {
1182 c->enabled = 1;
1183 break;
1184 }
1185 }
1186
1187 if (!c->name) {
1188 if (l > 80) {
1189 fprintf(stderr,
1190 "Unknown sound card name (too big to show)\n");
1191 }
1192 else {
1193 fprintf(stderr, "Unknown sound card name `%.*s'\n",
1194 (int) l, p);
1195 }
1196 bad_card = 1;
1197 }
1198 p += l + (e != NULL);
1199 }
1200
1201 if (bad_card) {
1202 goto show_valid_cards;
1203 }
1204 }
1205}
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001206
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001207void audio_init(void)
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001208{
1209 struct soundhw *c;
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001210 ISABus *isa_bus = (ISABus *) object_resolve_path_type("", TYPE_ISA_BUS, NULL);
1211 PCIBus *pci_bus = (PCIBus *) object_resolve_path_type("", TYPE_PCI_BUS, NULL);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001212
1213 for (c = soundhw; c->name; ++c) {
1214 if (c->enabled) {
1215 if (c->isa) {
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001216 if (!isa_bus) {
1217 fprintf(stderr, "ISA bus not available for %s\n", c->name);
1218 exit(1);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001219 }
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001220 c->init.init_isa(isa_bus);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001221 } else {
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001222 if (!pci_bus) {
1223 fprintf(stderr, "PCI bus not available for %s\n", c->name);
1224 exit(1);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001225 }
Paolo Bonzinif81222b2013-04-18 18:44:03 +02001226 c->init.init_pci(pci_bus);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001227 }
1228 }
1229 }
1230}
Blue Swirlad960902010-03-29 19:23:52 +00001231
1232int qemu_uuid_parse(const char *str, uint8_t *uuid)
1233{
1234 int ret;
1235
1236 if (strlen(str) != 36) {
1237 return -1;
1238 }
1239
1240 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1241 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1242 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1243 &uuid[15]);
1244
1245 if (ret != 16) {
1246 return -1;
1247 }
Blue Swirlad960902010-03-29 19:23:52 +00001248 return 0;
1249}
1250
Laszlo Ersek0c764a92013-03-21 00:23:17 +01001251void do_acpitable_option(const QemuOpts *opts)
Blue Swirlad960902010-03-29 19:23:52 +00001252{
1253#ifdef TARGET_I386
Laszlo Ersek23084322013-03-21 00:23:19 +01001254 Error *err = NULL;
1255
1256 acpi_table_add(opts, &err);
1257 if (err) {
Seiji Aguchi4a44d852013-08-05 15:40:44 -04001258 error_report("Wrong acpi table provided: %s",
1259 error_get_pretty(err));
Laszlo Ersek23084322013-03-21 00:23:19 +01001260 error_free(err);
Blue Swirlad960902010-03-29 19:23:52 +00001261 exit(1);
1262 }
1263#endif
1264}
1265
Markus Armbruster4f953d22013-08-16 15:18:29 +02001266void do_smbios_option(QemuOpts *opts)
Blue Swirlad960902010-03-29 19:23:52 +00001267{
1268#ifdef TARGET_I386
Markus Armbruster4f953d22013-08-16 15:18:29 +02001269 smbios_entry_add(opts);
Blue Swirlad960902010-03-29 19:23:52 +00001270#endif
1271}
1272
1273void cpudef_init(void)
1274{
1275#if defined(cpudef_setup)
1276 cpudef_setup(); /* parse cpu definitions in target config file */
1277#endif
1278}
1279
Anthony PERARD303d4e82010-09-21 20:05:31 +01001280int tcg_available(void)
1281{
1282 return 1;
1283}
1284
Blue Swirlad960902010-03-29 19:23:52 +00001285int kvm_available(void)
1286{
1287#ifdef CONFIG_KVM
1288 return 1;
1289#else
1290 return 0;
1291#endif
1292}
1293
1294int xen_available(void)
1295{
1296#ifdef CONFIG_XEN
1297 return 1;
1298#else
1299 return 0;
1300#endif
1301}
Daniel P. Berrange99afc912012-08-20 15:31:38 +01001302
1303
1304TargetInfo *qmp_query_target(Error **errp)
1305{
1306 TargetInfo *info = g_malloc0(sizeof(*info));
1307
Paolo Bonzinic02a9552013-06-04 14:45:28 +02001308 info->arch = g_strdup(TARGET_NAME);
Daniel P. Berrange99afc912012-08-20 15:31:38 +01001309
1310 return info;
1311}
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001312
1313/* Stub function that's gets run on the vcpu when its brought out of the
1314 VM to run inside qemu via async_run_on_cpu()*/
1315static void mig_sleep_cpu(void *opq)
1316{
1317 qemu_mutex_unlock_iothread();
1318 g_usleep(30*1000);
1319 qemu_mutex_lock_iothread();
1320}
1321
1322/* To reduce the dirty rate explicitly disallow the VCPUs from spending
1323 much time in the VM. The migration thread will try to catchup.
1324 Workload will experience a performance drop.
1325*/
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001326static void mig_throttle_guest_down(void)
1327{
Andreas Färber38fcbd32013-07-07 19:50:23 +02001328 CPUState *cpu;
1329
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001330 qemu_mutex_lock_iothread();
Andreas Färber38fcbd32013-07-07 19:50:23 +02001331 CPU_FOREACH(cpu) {
1332 async_run_on_cpu(cpu, mig_sleep_cpu, NULL);
1333 }
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001334 qemu_mutex_unlock_iothread();
1335}
1336
1337static void check_guest_throttling(void)
1338{
1339 static int64_t t0;
1340 int64_t t1;
1341
1342 if (!mig_throttle_on) {
1343 return;
1344 }
1345
1346 if (!t0) {
Alex Blighbc72ad62013-08-21 16:03:08 +01001347 t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001348 return;
1349 }
1350
Alex Blighbc72ad62013-08-21 16:03:08 +01001351 t1 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Chegu Vinod7ca1dfa2013-06-24 03:47:39 -06001352
1353 /* If it has been more than 40 ms since the last time the guest
1354 * was throttled then do it again.
1355 */
1356 if (40 < (t1-t0)/1000000) {
1357 mig_throttle_guest_down();
1358 t0 = t1;
1359 }
1360}