]> Git Repo - qemu.git/blame - arch_init.c
target-arm: A64: Implement scalar three different instructions
[qemu.git] / arch_init.c
CommitLineData
ad96090a
BS
1/*
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>
b2e0a138 26#include <stdlib.h>
ad96090a 27#ifndef _WIN32
1c47cb16 28#include <sys/types.h>
ad96090a
BS
29#include <sys/mman.h>
30#endif
31#include "config.h"
83c9089e 32#include "monitor/monitor.h"
9c17d615 33#include "sysemu/sysemu.h"
1de7afc9
PB
34#include "qemu/bitops.h"
35#include "qemu/bitmap.h"
9c17d615 36#include "sysemu/arch_init.h"
ad96090a 37#include "audio/audio.h"
0d09e41a 38#include "hw/i386/pc.h"
a2cb15b0 39#include "hw/pci/pci.h"
0d09e41a 40#include "hw/audio/audio.h"
9c17d615 41#include "sysemu/kvm.h"
caf71f86 42#include "migration/migration.h"
0d09e41a 43#include "hw/i386/smbios.h"
022c62cb 44#include "exec/address-spaces.h"
0d09e41a 45#include "hw/audio/pcspk.h"
caf71f86 46#include "migration/page_cache.h"
1de7afc9 47#include "qemu/config-file.h"
99afc91d 48#include "qmp-commands.h"
3c12193d 49#include "trace.h"
0d6d3c87 50#include "exec/cpu-all.h"
12291ec1 51#include "exec/ram_addr.h"
0445259b 52#include "hw/acpi/acpi.h"
aa8dc044 53#include "qemu/host-utils.h"
ad96090a 54
3a697f69
OW
55#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
ad96090a
BS
63#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;
f1ff0e89 70int graphic_depth = 32;
ad96090a
BS
71#endif
72
ad96090a
BS
73
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
81ea0e13
MW
84#elif defined(TARGET_LM32)
85#define QEMU_ARCH QEMU_ARCH_LM32
ad96090a
BS
86#elif defined(TARGET_MICROBLAZE)
87#define QEMU_ARCH QEMU_ARCH_MICROBLAZE
88#elif defined(TARGET_MIPS)
89#define QEMU_ARCH QEMU_ARCH_MIPS
d15a9c23
AG
90#elif defined(TARGET_MOXIE)
91#define QEMU_ARCH QEMU_ARCH_MOXIE
e67db06e
JL
92#elif defined(TARGET_OPENRISC)
93#define QEMU_ARCH QEMU_ARCH_OPENRISC
ad96090a
BS
94#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
2328826b
MF
102#elif defined(TARGET_XTENSA)
103#define QEMU_ARCH QEMU_ARCH_XTENSA
4f23a1e6
GX
104#elif defined(TARGET_UNICORE32)
105#define QEMU_ARCH QEMU_ARCH_UNICORE32
ad96090a
BS
106#endif
107
108const uint32_t arch_type = QEMU_ARCH;
7ca1dfad
CV
109static bool mig_throttle_on;
110static int dirty_rate_high_cnt;
111static void check_guest_throttling(void);
ad96090a
BS
112
113/***********************************************************/
114/* ram save/restore */
115
d20878d2
YT
116#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
17ad9b35 122#define RAM_SAVE_FLAG_XBZRLE 0x40
0033b8b4 123/* 0x80 is reserved in migration.h start with 0x100 next */
ad96090a 124
b5a8fe5e 125
756557de
EH
126static struct defconfig_file {
127 const char *filename;
f29a5614
EH
128 /* Indicates it is an user config file (disabled by -no-user-config) */
129 bool userconfig;
756557de 130} default_config_files[] = {
f29a5614 131 { CONFIG_QEMU_CONFDIR "/qemu.conf", true },
2e59915d 132 { CONFIG_QEMU_CONFDIR "/target-" TARGET_NAME ".conf", true },
756557de
EH
133 { NULL }, /* end of list */
134};
135
136
f29a5614 137int qemu_read_default_config_files(bool userconfig)
b5a8fe5e
EH
138{
139 int ret;
756557de 140 struct defconfig_file *f;
b5a8fe5e 141
756557de 142 for (f = default_config_files; f->filename; f++) {
f29a5614
EH
143 if (!userconfig && f->userconfig) {
144 continue;
145 }
756557de
EH
146 ret = qemu_read_config_file(f->filename);
147 if (ret < 0 && ret != -ENOENT) {
148 return ret;
149 }
b5a8fe5e 150 }
4d8b3c63 151
b5a8fe5e
EH
152 return 0;
153}
154
dc3c26a4 155static inline bool is_zero_range(uint8_t *p, uint64_t size)
ad96090a 156{
dc3c26a4 157 return buffer_find_nonzero_offset(p, size) == size;
ad96090a
BS
158}
159
17ad9b35
OW
160/* 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;
17ad9b35
OW
167 /* Cache for XBZRLE */
168 PageCache *cache;
169} XBZRLE = {
170 .encoded_buf = NULL,
171 .current_buf = NULL,
17ad9b35
OW
172 .cache = NULL,
173};
905f26f2
GA
174/* buffer used for XBZRLE decoding */
175static uint8_t *xbzrle_decoded_buf;
9e1ba4cc
OW
176
177int64_t xbzrle_cache_resize(int64_t new_size)
178{
c91e681a
OW
179 if (new_size < TARGET_PAGE_SIZE) {
180 return -1;
181 }
182
9e1ba4cc
OW
183 if (XBZRLE.cache != NULL) {
184 return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) *
185 TARGET_PAGE_SIZE;
186 }
187 return pow2floor(new_size);
188}
189
004d4c10
OW
190/* accounting for migration statistics */
191typedef struct AccountingInfo {
192 uint64_t dup_pages;
f1c72795 193 uint64_t skipped_pages;
004d4c10
OW
194 uint64_t norm_pages;
195 uint64_t iterations;
f36d55af
OW
196 uint64_t xbzrle_bytes;
197 uint64_t xbzrle_pages;
198 uint64_t xbzrle_cache_miss;
199 uint64_t xbzrle_overflows;
004d4c10
OW
200} AccountingInfo;
201
202static AccountingInfo acct_info;
203
204static void acct_clear(void)
205{
206 memset(&acct_info, 0, sizeof(acct_info));
207}
208
209uint64_t dup_mig_bytes_transferred(void)
210{
211 return acct_info.dup_pages * TARGET_PAGE_SIZE;
212}
213
214uint64_t dup_mig_pages_transferred(void)
215{
216 return acct_info.dup_pages;
217}
218
f1c72795
PL
219uint64_t skipped_mig_bytes_transferred(void)
220{
221 return acct_info.skipped_pages * TARGET_PAGE_SIZE;
222}
223
224uint64_t skipped_mig_pages_transferred(void)
225{
226 return acct_info.skipped_pages;
227}
228
004d4c10
OW
229uint64_t norm_mig_bytes_transferred(void)
230{
231 return acct_info.norm_pages * TARGET_PAGE_SIZE;
232}
233
234uint64_t norm_mig_pages_transferred(void)
235{
236 return acct_info.norm_pages;
237}
238
f36d55af
OW
239uint64_t xbzrle_mig_bytes_transferred(void)
240{
241 return acct_info.xbzrle_bytes;
242}
243
244uint64_t xbzrle_mig_pages_transferred(void)
245{
246 return acct_info.xbzrle_pages;
247}
248
249uint64_t xbzrle_mig_pages_cache_miss(void)
250{
251 return acct_info.xbzrle_cache_miss;
252}
253
254uint64_t xbzrle_mig_pages_overflow(void)
255{
256 return acct_info.xbzrle_overflows;
257}
258
3f7d7b09
JQ
259static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
260 int cont, int flag)
0c51f43d 261{
3f7d7b09
JQ
262 size_t size;
263
264 qemu_put_be64(f, offset | cont | flag);
265 size = 8;
0c51f43d 266
3f7d7b09
JQ
267 if (!cont) {
268 qemu_put_byte(f, strlen(block->idstr));
269 qemu_put_buffer(f, (uint8_t *)block->idstr,
270 strlen(block->idstr));
271 size += 1 + strlen(block->idstr);
272 }
273 return size;
0c51f43d
OW
274}
275
17ad9b35
OW
276#define ENCODING_FLAG_XBZRLE 0x1
277
278static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
279 ram_addr_t current_addr, RAMBlock *block,
dd051c72 280 ram_addr_t offset, int cont, bool last_stage)
17ad9b35
OW
281{
282 int encoded_len = 0, bytes_sent = -1;
283 uint8_t *prev_cached_page;
284
285 if (!cache_is_cached(XBZRLE.cache, current_addr)) {
dd051c72 286 if (!last_stage) {
89db9987
OW
287 if (cache_insert(XBZRLE.cache, current_addr, current_data) == -1) {
288 return -1;
289 }
dd051c72 290 }
f36d55af 291 acct_info.xbzrle_cache_miss++;
17ad9b35
OW
292 return -1;
293 }
294
295 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
296
297 /* save current buffer into memory */
298 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE);
299
300 /* XBZRLE encoding (if there is no overflow) */
301 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
302 TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
303 TARGET_PAGE_SIZE);
304 if (encoded_len == 0) {
305 DPRINTF("Skipping unmodified page\n");
306 return 0;
307 } else if (encoded_len == -1) {
308 DPRINTF("Overflow\n");
f36d55af 309 acct_info.xbzrle_overflows++;
17ad9b35
OW
310 /* update data in the cache */
311 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE);
312 return -1;
313 }
314
315 /* we need to update the data in the cache, in order to get the same data */
dd051c72
JQ
316 if (!last_stage) {
317 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
318 }
17ad9b35
OW
319
320 /* Send XBZRLE based compressed page */
3f7d7b09 321 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
17ad9b35
OW
322 qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
323 qemu_put_be16(f, encoded_len);
324 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
3f7d7b09 325 bytes_sent += encoded_len + 1 + 2;
f36d55af
OW
326 acct_info.xbzrle_pages++;
327 acct_info.xbzrle_bytes += bytes_sent;
17ad9b35
OW
328
329 return bytes_sent;
330}
331
b23a9a5c
JQ
332
333/* This is the last block that we have visited serching for dirty pages
334 */
335static RAMBlock *last_seen_block;
5f718a15
JQ
336/* This is the last block from where we have sent data */
337static RAMBlock *last_sent_block;
760e77ea 338static ram_addr_t last_offset;
c6bf8e0e
JQ
339static unsigned long *migration_bitmap;
340static uint64_t migration_dirty_pages;
f798b07f 341static uint32_t last_version;
78d07ae7 342static bool ram_bulk_stage;
760e77ea 343
4c8ae0f6
JQ
344static inline
345ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
346 ram_addr_t start)
69268cde 347{
4c8ae0f6
JQ
348 unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS;
349 unsigned long nr = base + (start >> TARGET_PAGE_BITS);
0851c9f7
MT
350 uint64_t mr_size = TARGET_PAGE_ALIGN(memory_region_size(mr));
351 unsigned long size = base + (mr_size >> TARGET_PAGE_BITS);
c6bf8e0e 352
70c8652b
PL
353 unsigned long next;
354
355 if (ram_bulk_stage && nr > base) {
356 next = nr + 1;
357 } else {
358 next = find_next_bit(migration_bitmap, size, nr);
359 }
69268cde 360
4c8ae0f6
JQ
361 if (next < size) {
362 clear_bit(next, migration_bitmap);
c6bf8e0e 363 migration_dirty_pages--;
69268cde 364 }
4c8ae0f6 365 return (next - base) << TARGET_PAGE_BITS;
69268cde
JQ
366}
367
791fa2a2 368static inline bool migration_bitmap_set_dirty(ram_addr_t addr)
e44d26c8 369{
c6bf8e0e 370 bool ret;
791fa2a2 371 int nr = addr >> TARGET_PAGE_BITS;
e44d26c8 372
c6bf8e0e
JQ
373 ret = test_and_set_bit(nr, migration_bitmap);
374
375 if (!ret) {
376 migration_dirty_pages++;
e44d26c8 377 }
c6bf8e0e 378 return ret;
e44d26c8
JQ
379}
380
791fa2a2
JQ
381static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length)
382{
383 ram_addr_t addr;
aa8dc044
JQ
384 unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
385
386 /* start address is aligned at the start of a word? */
387 if (((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) {
388 int k;
389 int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS);
390 unsigned long *src = ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION];
391
392 for (k = page; k < page + nr; k++) {
393 if (src[k]) {
394 unsigned long new_dirty;
395 new_dirty = ~migration_bitmap[k];
396 migration_bitmap[k] |= src[k];
397 new_dirty &= src[k];
398 migration_dirty_pages += ctpopl(new_dirty);
399 src[k] = 0;
400 }
401 }
402 } else {
403 for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) {
404 if (cpu_physical_memory_get_dirty(start + addr,
405 TARGET_PAGE_SIZE,
406 DIRTY_MEMORY_MIGRATION)) {
407 cpu_physical_memory_reset_dirty(start + addr,
408 TARGET_PAGE_SIZE,
409 DIRTY_MEMORY_MIGRATION);
410 migration_bitmap_set_dirty(start + addr);
411 }
791fa2a2
JQ
412 }
413 }
414}
415
416
32c835ba
PB
417/* Needs iothread lock! */
418
dd2df737
JQ
419static void migration_bitmap_sync(void)
420{
c6bf8e0e 421 RAMBlock *block;
c6bf8e0e 422 uint64_t num_dirty_pages_init = migration_dirty_pages;
8d017193
JQ
423 MigrationState *s = migrate_get_current();
424 static int64_t start_time;
7ca1dfad 425 static int64_t bytes_xfer_prev;
8d017193
JQ
426 static int64_t num_dirty_pages_period;
427 int64_t end_time;
7ca1dfad
CV
428 int64_t bytes_xfer_now;
429
430 if (!bytes_xfer_prev) {
431 bytes_xfer_prev = ram_bytes_transferred();
432 }
8d017193
JQ
433
434 if (!start_time) {
bc72ad67 435 start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
8d017193 436 }
3c12193d
JQ
437
438 trace_migration_bitmap_sync_start();
1d671369 439 address_space_sync_dirty_bitmap(&address_space_memory);
c6bf8e0e 440
a3161038 441 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
791fa2a2 442 migration_bitmap_sync_range(block->mr->ram_addr, block->length);
c6bf8e0e
JQ
443 }
444 trace_migration_bitmap_sync_end(migration_dirty_pages
3c12193d 445 - num_dirty_pages_init);
8d017193 446 num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
bc72ad67 447 end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
8d017193
JQ
448
449 /* more than 1 second = 1000 millisecons */
450 if (end_time > start_time + 1000) {
7ca1dfad
CV
451 if (migrate_auto_converge()) {
452 /* The following detection logic can be refined later. For now:
453 Check to see if the dirtied bytes is 50% more than the approx.
454 amount of bytes that just got transferred since the last time we
455 were in this routine. If that happens >N times (for now N==4)
456 we turn on the throttle down logic */
457 bytes_xfer_now = ram_bytes_transferred();
458 if (s->dirty_pages_rate &&
459 (num_dirty_pages_period * TARGET_PAGE_SIZE >
460 (bytes_xfer_now - bytes_xfer_prev)/2) &&
461 (dirty_rate_high_cnt++ > 4)) {
462 trace_migration_throttle();
463 mig_throttle_on = true;
464 dirty_rate_high_cnt = 0;
465 }
466 bytes_xfer_prev = bytes_xfer_now;
467 } else {
468 mig_throttle_on = false;
469 }
8d017193
JQ
470 s->dirty_pages_rate = num_dirty_pages_period * 1000
471 / (end_time - start_time);
90f8ae72 472 s->dirty_bytes_rate = s->dirty_pages_rate * TARGET_PAGE_SIZE;
8d017193
JQ
473 start_time = end_time;
474 num_dirty_pages_period = 0;
475 }
dd2df737
JQ
476}
477
6c779f22
OW
478/*
479 * ram_save_block: Writes a page of memory to the stream f
480 *
b823ceaa
JQ
481 * Returns: The number of bytes written.
482 * 0 means no dirty pages
6c779f22
OW
483 */
484
dd051c72 485static int ram_save_block(QEMUFile *f, bool last_stage)
ad96090a 486{
b23a9a5c 487 RAMBlock *block = last_seen_block;
e44359c3 488 ram_addr_t offset = last_offset;
4c8ae0f6 489 bool complete_round = false;
b823ceaa 490 int bytes_sent = 0;
71c510e2 491 MemoryRegion *mr;
17ad9b35 492 ram_addr_t current_addr;
ad96090a 493
e44359c3 494 if (!block)
a3161038 495 block = QTAILQ_FIRST(&ram_list.blocks);
e44359c3 496
4c8ae0f6 497 while (true) {
71c510e2 498 mr = block->mr;
4c8ae0f6
JQ
499 offset = migration_bitmap_find_and_reset_dirty(mr, offset);
500 if (complete_round && block == last_seen_block &&
501 offset >= last_offset) {
502 break;
503 }
504 if (offset >= block->length) {
505 offset = 0;
506 block = QTAILQ_NEXT(block, next);
507 if (!block) {
508 block = QTAILQ_FIRST(&ram_list.blocks);
509 complete_round = true;
78d07ae7 510 ram_bulk_stage = false;
4c8ae0f6
JQ
511 }
512 } else {
0033b8b4 513 int ret;
ad96090a 514 uint8_t *p;
5f718a15 515 int cont = (block == last_sent_block) ?
b23a9a5c 516 RAM_SAVE_FLAG_CONTINUE : 0;
ad96090a 517
71c510e2 518 p = memory_region_get_ram_ptr(mr) + offset;
ad96090a 519
b823ceaa
JQ
520 /* In doubt sent page as normal */
521 bytes_sent = -1;
0033b8b4
MH
522 ret = ram_control_save_page(f, block->offset,
523 offset, TARGET_PAGE_SIZE, &bytes_sent);
524
525 if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
526 if (ret != RAM_SAVE_CONTROL_DELAYED) {
527 if (bytes_sent > 0) {
528 acct_info.norm_pages++;
529 } else if (bytes_sent == 0) {
530 acct_info.dup_pages++;
531 }
532 }
dc3c26a4 533 } else if (is_zero_range(p, TARGET_PAGE_SIZE)) {
004d4c10 534 acct_info.dup_pages++;
9ef051e5
PL
535 bytes_sent = save_block_hdr(f, block, offset, cont,
536 RAM_SAVE_FLAG_COMPRESS);
537 qemu_put_byte(f, 0);
538 bytes_sent++;
5cc11c46 539 } else if (!ram_bulk_stage && migrate_use_xbzrle()) {
17ad9b35
OW
540 current_addr = block->offset + offset;
541 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
dd051c72
JQ
542 offset, cont, last_stage);
543 if (!last_stage) {
544 p = get_cached_data(XBZRLE.cache, current_addr);
545 }
17ad9b35
OW
546 }
547
b823ceaa 548 /* XBZRLE overflow or normal page */
17ad9b35 549 if (bytes_sent == -1) {
3f7d7b09 550 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
500f0061 551 qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE);
3f7d7b09 552 bytes_sent += TARGET_PAGE_SIZE;
004d4c10 553 acct_info.norm_pages++;
ad96090a
BS
554 }
555
17ad9b35 556 /* if page is unmodified, continue to the next */
b823ceaa 557 if (bytes_sent > 0) {
5f718a15 558 last_sent_block = block;
17ad9b35
OW
559 break;
560 }
ad96090a 561 }
4c8ae0f6 562 }
b23a9a5c 563 last_seen_block = block;
e44359c3 564 last_offset = offset;
ad96090a 565
3fc250b4 566 return bytes_sent;
ad96090a
BS
567}
568
569static uint64_t bytes_transferred;
570
2b0ce079
MH
571void acct_update_position(QEMUFile *f, size_t size, bool zero)
572{
573 uint64_t pages = size / TARGET_PAGE_SIZE;
574 if (zero) {
575 acct_info.dup_pages += pages;
576 } else {
577 acct_info.norm_pages += pages;
578 bytes_transferred += size;
579 qemu_update_position(f, size);
580 }
581}
582
ad96090a
BS
583static ram_addr_t ram_save_remaining(void)
584{
c6bf8e0e 585 return migration_dirty_pages;
ad96090a
BS
586}
587
588uint64_t ram_bytes_remaining(void)
589{
590 return ram_save_remaining() * TARGET_PAGE_SIZE;
591}
592
593uint64_t ram_bytes_transferred(void)
594{
595 return bytes_transferred;
596}
597
598uint64_t ram_bytes_total(void)
599{
d17b5288
AW
600 RAMBlock *block;
601 uint64_t total = 0;
602
a3161038 603 QTAILQ_FOREACH(block, &ram_list.blocks, next)
d17b5288
AW
604 total += block->length;
605
606 return total;
ad96090a
BS
607}
608
905f26f2
GA
609void free_xbzrle_decoded_buf(void)
610{
611 g_free(xbzrle_decoded_buf);
612 xbzrle_decoded_buf = NULL;
613}
614
8e21cd32
OW
615static void migration_end(void)
616{
244eaa75
PB
617 if (migration_bitmap) {
618 memory_global_dirty_log_stop();
619 g_free(migration_bitmap);
620 migration_bitmap = NULL;
621 }
17ad9b35 622
244eaa75 623 if (XBZRLE.cache) {
17ad9b35
OW
624 cache_fini(XBZRLE.cache);
625 g_free(XBZRLE.cache);
626 g_free(XBZRLE.encoded_buf);
627 g_free(XBZRLE.current_buf);
17ad9b35 628 XBZRLE.cache = NULL;
f6c6483b
OW
629 XBZRLE.encoded_buf = NULL;
630 XBZRLE.current_buf = NULL;
17ad9b35 631 }
8e21cd32
OW
632}
633
9b5bfab0
JQ
634static void ram_migration_cancel(void *opaque)
635{
636 migration_end();
637}
638
5a170775
JQ
639static void reset_ram_globals(void)
640{
b23a9a5c 641 last_seen_block = NULL;
5f718a15 642 last_sent_block = NULL;
5a170775 643 last_offset = 0;
f798b07f 644 last_version = ram_list.version;
78d07ae7 645 ram_bulk_stage = true;
5a170775
JQ
646}
647
4508bd9e
JQ
648#define MAX_WAIT 50 /* ms, half buffered_file limit */
649
d1315aac 650static int ram_save_setup(QEMUFile *f, void *opaque)
ad96090a 651{
d1315aac 652 RAMBlock *block;
c6bf8e0e
JQ
653 int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
654
655 migration_bitmap = bitmap_new(ram_pages);
7ec81e56 656 bitmap_set(migration_bitmap, 0, ram_pages);
c6bf8e0e 657 migration_dirty_pages = ram_pages;
7ca1dfad
CV
658 mig_throttle_on = false;
659 dirty_rate_high_cnt = 0;
ad96090a 660
17ad9b35
OW
661 if (migrate_use_xbzrle()) {
662 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
663 TARGET_PAGE_SIZE,
664 TARGET_PAGE_SIZE);
665 if (!XBZRLE.cache) {
666 DPRINTF("Error creating cache\n");
667 return -1;
668 }
a17b2fd3
OW
669
670 /* We prefer not to abort if there is no memory */
671 XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);
672 if (!XBZRLE.encoded_buf) {
673 DPRINTF("Error allocating encoded_buf\n");
674 return -1;
675 }
676
677 XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);
678 if (!XBZRLE.current_buf) {
679 DPRINTF("Error allocating current_buf\n");
680 g_free(XBZRLE.encoded_buf);
681 XBZRLE.encoded_buf = NULL;
682 return -1;
683 }
684
004d4c10 685 acct_clear();
17ad9b35
OW
686 }
687
9b095037
PB
688 qemu_mutex_lock_iothread();
689 qemu_mutex_lock_ramlist();
690 bytes_transferred = 0;
691 reset_ram_globals();
692
d1315aac 693 memory_global_dirty_log_start();
c6bf8e0e 694 migration_bitmap_sync();
9b095037 695 qemu_mutex_unlock_iothread();
ad96090a 696
d1315aac 697 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
97ab12d4 698
a3161038 699 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
d1315aac
JQ
700 qemu_put_byte(f, strlen(block->idstr));
701 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
702 qemu_put_be64(f, block->length);
ad96090a
BS
703 }
704
b2a8658e 705 qemu_mutex_unlock_ramlist();
0033b8b4
MH
706
707 ram_control_before_iterate(f, RAM_CONTROL_SETUP);
708 ram_control_after_iterate(f, RAM_CONTROL_SETUP);
709
d1315aac
JQ
710 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
711
712 return 0;
713}
714
16310a3c 715static int ram_save_iterate(QEMUFile *f, void *opaque)
d1315aac 716{
d1315aac
JQ
717 int ret;
718 int i;
e4ed1541 719 int64_t t0;
b823ceaa 720 int total_sent = 0;
d1315aac 721
b2a8658e
UD
722 qemu_mutex_lock_ramlist();
723
f798b07f
UD
724 if (ram_list.version != last_version) {
725 reset_ram_globals();
726 }
727
0033b8b4
MH
728 ram_control_before_iterate(f, RAM_CONTROL_ROUND);
729
bc72ad67 730 t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
4508bd9e 731 i = 0;
2975725f 732 while ((ret = qemu_file_rate_limit(f)) == 0) {
3fc250b4 733 int bytes_sent;
ad96090a 734
dd051c72 735 bytes_sent = ram_save_block(f, false);
6c779f22 736 /* no more blocks to sent */
b823ceaa 737 if (bytes_sent == 0) {
ad96090a
BS
738 break;
739 }
b823ceaa 740 total_sent += bytes_sent;
004d4c10 741 acct_info.iterations++;
7ca1dfad 742 check_guest_throttling();
4508bd9e
JQ
743 /* we want to check in the 1st loop, just in case it was the 1st time
744 and we had to sync the dirty bitmap.
745 qemu_get_clock_ns() is a bit expensive, so we only check each some
746 iterations
747 */
748 if ((i & 63) == 0) {
bc72ad67 749 uint64_t t1 = (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - t0) / 1000000;
4508bd9e 750 if (t1 > MAX_WAIT) {
ef37a699 751 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
4508bd9e
JQ
752 t1, i);
753 break;
754 }
755 }
756 i++;
ad96090a
BS
757 }
758
fb3409de
PB
759 qemu_mutex_unlock_ramlist();
760
0033b8b4
MH
761 /*
762 * Must occur before EOS (or any QEMUFile operation)
763 * because of RDMA protocol.
764 */
765 ram_control_after_iterate(f, RAM_CONTROL_ROUND);
766
6cd0beda
LL
767 bytes_transferred += total_sent;
768
769 /*
770 * Do not count these 8 bytes into total_sent, so that we can
771 * return 0 if no page had been dirtied.
772 */
773 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
774 bytes_transferred += 8;
775
776 ret = qemu_file_get_error(f);
2975725f
JQ
777 if (ret < 0) {
778 return ret;
779 }
780
b823ceaa 781 return total_sent;
16310a3c
JQ
782}
783
784static int ram_save_complete(QEMUFile *f, void *opaque)
785{
b2a8658e 786 qemu_mutex_lock_ramlist();
9c339485 787 migration_bitmap_sync();
b2a8658e 788
0033b8b4
MH
789 ram_control_before_iterate(f, RAM_CONTROL_FINISH);
790
ad96090a 791 /* try transferring iterative blocks of memory */
3a697f69 792
16310a3c 793 /* flush all remaining blocks regardless of rate limiting */
6c779f22 794 while (true) {
3fc250b4
PR
795 int bytes_sent;
796
dd051c72 797 bytes_sent = ram_save_block(f, true);
6c779f22 798 /* no more blocks to sent */
b823ceaa 799 if (bytes_sent == 0) {
6c779f22 800 break;
ad96090a 801 }
16310a3c 802 bytes_transferred += bytes_sent;
ad96090a 803 }
0033b8b4
MH
804
805 ram_control_after_iterate(f, RAM_CONTROL_FINISH);
244eaa75 806 migration_end();
ad96090a 807
b2a8658e 808 qemu_mutex_unlock_ramlist();
ad96090a
BS
809 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
810
5b3c9638 811 return 0;
ad96090a
BS
812}
813
e4ed1541
JQ
814static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size)
815{
816 uint64_t remaining_size;
817
818 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
819
820 if (remaining_size < max_size) {
32c835ba 821 qemu_mutex_lock_iothread();
e4ed1541 822 migration_bitmap_sync();
32c835ba 823 qemu_mutex_unlock_iothread();
e4ed1541
JQ
824 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
825 }
826 return remaining_size;
827}
828
17ad9b35
OW
829static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
830{
831 int ret, rc = 0;
832 unsigned int xh_len;
833 int xh_flags;
834
905f26f2
GA
835 if (!xbzrle_decoded_buf) {
836 xbzrle_decoded_buf = g_malloc(TARGET_PAGE_SIZE);
17ad9b35
OW
837 }
838
839 /* extract RLE header */
840 xh_flags = qemu_get_byte(f);
841 xh_len = qemu_get_be16(f);
842
843 if (xh_flags != ENCODING_FLAG_XBZRLE) {
844 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
845 return -1;
846 }
847
848 if (xh_len > TARGET_PAGE_SIZE) {
849 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
850 return -1;
851 }
852 /* load data and decode */
905f26f2 853 qemu_get_buffer(f, xbzrle_decoded_buf, xh_len);
17ad9b35
OW
854
855 /* decode RLE */
905f26f2 856 ret = xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host,
17ad9b35
OW
857 TARGET_PAGE_SIZE);
858 if (ret == -1) {
859 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
860 rc = -1;
861 } else if (ret > TARGET_PAGE_SIZE) {
862 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
863 ret, TARGET_PAGE_SIZE);
864 abort();
865 }
866
867 return rc;
868}
869
a55bbe31
AW
870static inline void *host_from_stream_offset(QEMUFile *f,
871 ram_addr_t offset,
872 int flags)
873{
874 static RAMBlock *block = NULL;
875 char id[256];
876 uint8_t len;
877
878 if (flags & RAM_SAVE_FLAG_CONTINUE) {
879 if (!block) {
880 fprintf(stderr, "Ack, bad migration stream!\n");
881 return NULL;
882 }
883
dc94a7ed 884 return memory_region_get_ram_ptr(block->mr) + offset;
a55bbe31
AW
885 }
886
887 len = qemu_get_byte(f);
888 qemu_get_buffer(f, (uint8_t *)id, len);
889 id[len] = 0;
890
a3161038 891 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
a55bbe31 892 if (!strncmp(id, block->idstr, sizeof(id)))
dc94a7ed 893 return memory_region_get_ram_ptr(block->mr) + offset;
a55bbe31
AW
894 }
895
896 fprintf(stderr, "Can't find block %s!\n", id);
897 return NULL;
898}
899
44c3b58c
MH
900/*
901 * If a page (or a whole RDMA chunk) has been
902 * determined to be zero, then zap it.
903 */
904void ram_handle_compressed(void *host, uint8_t ch, uint64_t size)
905{
d613a56f 906 if (ch != 0 || !is_zero_range(host, size)) {
44c3b58c 907 memset(host, ch, size);
44c3b58c
MH
908 }
909}
910
7908c78d 911static int ram_load(QEMUFile *f, void *opaque, int version_id)
ad96090a
BS
912{
913 ram_addr_t addr;
3a697f69 914 int flags, ret = 0;
42802d47 915 int error;
3a697f69
OW
916 static uint64_t seq_iter;
917
918 seq_iter++;
ad96090a 919
f09f2189 920 if (version_id < 4 || version_id > 4) {
ad96090a
BS
921 return -EINVAL;
922 }
923
924 do {
925 addr = qemu_get_be64(f);
926
927 flags = addr & ~TARGET_PAGE_MASK;
928 addr &= TARGET_PAGE_MASK;
929
930 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
f09f2189 931 if (version_id == 4) {
97ab12d4
AW
932 /* Synchronize RAM block list */
933 char id[256];
934 ram_addr_t length;
935 ram_addr_t total_ram_bytes = addr;
936
937 while (total_ram_bytes) {
938 RAMBlock *block;
939 uint8_t len;
940
941 len = qemu_get_byte(f);
942 qemu_get_buffer(f, (uint8_t *)id, len);
943 id[len] = 0;
944 length = qemu_get_be64(f);
945
a3161038 946 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
97ab12d4 947 if (!strncmp(id, block->idstr, sizeof(id))) {
3a697f69 948 if (block->length != length) {
6bedfe94
SW
949 fprintf(stderr,
950 "Length mismatch: %s: " RAM_ADDR_FMT
951 " in != " RAM_ADDR_FMT "\n", id, length,
87d2f825 952 block->length);
3a697f69
OW
953 ret = -EINVAL;
954 goto done;
955 }
97ab12d4
AW
956 break;
957 }
958 }
959
960 if (!block) {
fb787f81
AW
961 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
962 "accept migration\n", id);
3a697f69
OW
963 ret = -EINVAL;
964 goto done;
97ab12d4
AW
965 }
966
967 total_ram_bytes -= length;
968 }
ad96090a
BS
969 }
970 }
971
972 if (flags & RAM_SAVE_FLAG_COMPRESS) {
97ab12d4
AW
973 void *host;
974 uint8_t ch;
975
f09f2189 976 host = host_from_stream_offset(f, addr, flags);
492fb99c
MT
977 if (!host) {
978 return -EINVAL;
979 }
97ab12d4 980
97ab12d4 981 ch = qemu_get_byte(f);
44c3b58c 982 ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);
ad96090a 983 } else if (flags & RAM_SAVE_FLAG_PAGE) {
97ab12d4
AW
984 void *host;
985
f09f2189 986 host = host_from_stream_offset(f, addr, flags);
0ff1f9f5
OW
987 if (!host) {
988 return -EINVAL;
989 }
97ab12d4 990
97ab12d4 991 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
17ad9b35 992 } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
17ad9b35
OW
993 void *host = host_from_stream_offset(f, addr, flags);
994 if (!host) {
995 return -EINVAL;
996 }
997
998 if (load_xbzrle(f, addr, host) < 0) {
999 ret = -EINVAL;
1000 goto done;
1001 }
0033b8b4
MH
1002 } else if (flags & RAM_SAVE_FLAG_HOOK) {
1003 ram_control_load_hook(f, flags);
ad96090a 1004 }
42802d47
JQ
1005 error = qemu_file_get_error(f);
1006 if (error) {
3a697f69
OW
1007 ret = error;
1008 goto done;
ad96090a
BS
1009 }
1010 } while (!(flags & RAM_SAVE_FLAG_EOS));
1011
3a697f69 1012done:
ef37a699
IM
1013 DPRINTF("Completed load of VM with exit code %d seq iteration "
1014 "%" PRIu64 "\n", ret, seq_iter);
3a697f69 1015 return ret;
ad96090a
BS
1016}
1017
7908c78d 1018SaveVMHandlers savevm_ram_handlers = {
d1315aac 1019 .save_live_setup = ram_save_setup,
16310a3c
JQ
1020 .save_live_iterate = ram_save_iterate,
1021 .save_live_complete = ram_save_complete,
e4ed1541 1022 .save_live_pending = ram_save_pending,
7908c78d 1023 .load_state = ram_load,
9b5bfab0 1024 .cancel = ram_migration_cancel,
7908c78d
JQ
1025};
1026
0dfa5ef9
IY
1027struct soundhw {
1028 const char *name;
1029 const char *descr;
1030 int enabled;
1031 int isa;
1032 union {
4a0f031d 1033 int (*init_isa) (ISABus *bus);
0dfa5ef9
IY
1034 int (*init_pci) (PCIBus *bus);
1035 } init;
1036};
1037
36cd6f6f
PB
1038static struct soundhw soundhw[9];
1039static int soundhw_count;
ad96090a 1040
36cd6f6f
PB
1041void isa_register_soundhw(const char *name, const char *descr,
1042 int (*init_isa)(ISABus *bus))
1043{
1044 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
1045 soundhw[soundhw_count].name = name;
1046 soundhw[soundhw_count].descr = descr;
1047 soundhw[soundhw_count].isa = 1;
1048 soundhw[soundhw_count].init.init_isa = init_isa;
1049 soundhw_count++;
1050}
ad96090a 1051
36cd6f6f
PB
1052void pci_register_soundhw(const char *name, const char *descr,
1053 int (*init_pci)(PCIBus *bus))
1054{
1055 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
1056 soundhw[soundhw_count].name = name;
1057 soundhw[soundhw_count].descr = descr;
1058 soundhw[soundhw_count].isa = 0;
1059 soundhw[soundhw_count].init.init_pci = init_pci;
1060 soundhw_count++;
1061}
ad96090a
BS
1062
1063void select_soundhw(const char *optarg)
1064{
1065 struct soundhw *c;
1066
c8057f95 1067 if (is_help_option(optarg)) {
ad96090a
BS
1068 show_valid_cards:
1069
36cd6f6f
PB
1070 if (soundhw_count) {
1071 printf("Valid sound card names (comma separated):\n");
1072 for (c = soundhw; c->name; ++c) {
1073 printf ("%-11s %s\n", c->name, c->descr);
1074 }
1075 printf("\n-soundhw all will enable all of the above\n");
1076 } else {
1077 printf("Machine has no user-selectable audio hardware "
1078 "(it may or may not have always-present audio hardware).\n");
ad96090a 1079 }
c8057f95 1080 exit(!is_help_option(optarg));
ad96090a
BS
1081 }
1082 else {
1083 size_t l;
1084 const char *p;
1085 char *e;
1086 int bad_card = 0;
1087
1088 if (!strcmp(optarg, "all")) {
1089 for (c = soundhw; c->name; ++c) {
1090 c->enabled = 1;
1091 }
1092 return;
1093 }
1094
1095 p = optarg;
1096 while (*p) {
1097 e = strchr(p, ',');
1098 l = !e ? strlen(p) : (size_t) (e - p);
1099
1100 for (c = soundhw; c->name; ++c) {
1101 if (!strncmp(c->name, p, l) && !c->name[l]) {
1102 c->enabled = 1;
1103 break;
1104 }
1105 }
1106
1107 if (!c->name) {
1108 if (l > 80) {
1109 fprintf(stderr,
1110 "Unknown sound card name (too big to show)\n");
1111 }
1112 else {
1113 fprintf(stderr, "Unknown sound card name `%.*s'\n",
1114 (int) l, p);
1115 }
1116 bad_card = 1;
1117 }
1118 p += l + (e != NULL);
1119 }
1120
1121 if (bad_card) {
1122 goto show_valid_cards;
1123 }
1124 }
1125}
0dfa5ef9 1126
f81222bc 1127void audio_init(void)
0dfa5ef9
IY
1128{
1129 struct soundhw *c;
f81222bc
PB
1130 ISABus *isa_bus = (ISABus *) object_resolve_path_type("", TYPE_ISA_BUS, NULL);
1131 PCIBus *pci_bus = (PCIBus *) object_resolve_path_type("", TYPE_PCI_BUS, NULL);
0dfa5ef9
IY
1132
1133 for (c = soundhw; c->name; ++c) {
1134 if (c->enabled) {
1135 if (c->isa) {
f81222bc
PB
1136 if (!isa_bus) {
1137 fprintf(stderr, "ISA bus not available for %s\n", c->name);
1138 exit(1);
0dfa5ef9 1139 }
f81222bc 1140 c->init.init_isa(isa_bus);
0dfa5ef9 1141 } else {
f81222bc
PB
1142 if (!pci_bus) {
1143 fprintf(stderr, "PCI bus not available for %s\n", c->name);
1144 exit(1);
0dfa5ef9 1145 }
f81222bc 1146 c->init.init_pci(pci_bus);
0dfa5ef9
IY
1147 }
1148 }
1149 }
1150}
ad96090a
BS
1151
1152int qemu_uuid_parse(const char *str, uint8_t *uuid)
1153{
1154 int ret;
1155
1156 if (strlen(str) != 36) {
1157 return -1;
1158 }
1159
1160 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1161 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1162 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1163 &uuid[15]);
1164
1165 if (ret != 16) {
1166 return -1;
1167 }
ad96090a
BS
1168 return 0;
1169}
1170
0c764a9d 1171void do_acpitable_option(const QemuOpts *opts)
ad96090a
BS
1172{
1173#ifdef TARGET_I386
23084327
LE
1174 Error *err = NULL;
1175
1176 acpi_table_add(opts, &err);
1177 if (err) {
4a44d85e
SA
1178 error_report("Wrong acpi table provided: %s",
1179 error_get_pretty(err));
23084327 1180 error_free(err);
ad96090a
BS
1181 exit(1);
1182 }
1183#endif
1184}
1185
4f953d2f 1186void do_smbios_option(QemuOpts *opts)
ad96090a
BS
1187{
1188#ifdef TARGET_I386
4f953d2f 1189 smbios_entry_add(opts);
ad96090a
BS
1190#endif
1191}
1192
1193void cpudef_init(void)
1194{
1195#if defined(cpudef_setup)
1196 cpudef_setup(); /* parse cpu definitions in target config file */
1197#endif
1198}
1199
303d4e86
AP
1200int tcg_available(void)
1201{
1202 return 1;
1203}
1204
ad96090a
BS
1205int kvm_available(void)
1206{
1207#ifdef CONFIG_KVM
1208 return 1;
1209#else
1210 return 0;
1211#endif
1212}
1213
1214int xen_available(void)
1215{
1216#ifdef CONFIG_XEN
1217 return 1;
1218#else
1219 return 0;
1220#endif
1221}
99afc91d
DB
1222
1223
1224TargetInfo *qmp_query_target(Error **errp)
1225{
1226 TargetInfo *info = g_malloc0(sizeof(*info));
1227
c02a9552 1228 info->arch = g_strdup(TARGET_NAME);
99afc91d
DB
1229
1230 return info;
1231}
7ca1dfad
CV
1232
1233/* Stub function that's gets run on the vcpu when its brought out of the
1234 VM to run inside qemu via async_run_on_cpu()*/
1235static void mig_sleep_cpu(void *opq)
1236{
1237 qemu_mutex_unlock_iothread();
1238 g_usleep(30*1000);
1239 qemu_mutex_lock_iothread();
1240}
1241
1242/* To reduce the dirty rate explicitly disallow the VCPUs from spending
1243 much time in the VM. The migration thread will try to catchup.
1244 Workload will experience a performance drop.
1245*/
7ca1dfad
CV
1246static void mig_throttle_guest_down(void)
1247{
38fcbd3f
AF
1248 CPUState *cpu;
1249
7ca1dfad 1250 qemu_mutex_lock_iothread();
38fcbd3f
AF
1251 CPU_FOREACH(cpu) {
1252 async_run_on_cpu(cpu, mig_sleep_cpu, NULL);
1253 }
7ca1dfad
CV
1254 qemu_mutex_unlock_iothread();
1255}
1256
1257static void check_guest_throttling(void)
1258{
1259 static int64_t t0;
1260 int64_t t1;
1261
1262 if (!mig_throttle_on) {
1263 return;
1264 }
1265
1266 if (!t0) {
bc72ad67 1267 t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
7ca1dfad
CV
1268 return;
1269 }
1270
bc72ad67 1271 t1 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
7ca1dfad
CV
1272
1273 /* If it has been more than 40 ms since the last time the guest
1274 * was throttled then do it again.
1275 */
1276 if (40 < (t1-t0)/1000000) {
1277 mig_throttle_guest_down();
1278 t0 = t1;
1279 }
1280}
This page took 0.451922 seconds and 4 git commands to generate.