4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
28 #include <sys/types.h>
32 #include "monitor/monitor.h"
33 #include "sysemu/sysemu.h"
34 #include "qemu/bitops.h"
35 #include "qemu/bitmap.h"
36 #include "sysemu/arch_init.h"
37 #include "audio/audio.h"
38 #include "hw/i386/pc.h"
39 #include "hw/pci/pci.h"
40 #include "hw/audio/audio.h"
41 #include "sysemu/kvm.h"
42 #include "migration/migration.h"
43 #include "hw/i386/smbios.h"
44 #include "exec/address-spaces.h"
45 #include "hw/audio/pcspk.h"
46 #include "migration/page_cache.h"
47 #include "qemu/config-file.h"
48 #include "qemu/error-report.h"
49 #include "qmp-commands.h"
51 #include "exec/cpu-all.h"
52 #include "exec/ram_addr.h"
53 #include "hw/acpi/acpi.h"
54 #include "qemu/host-utils.h"
56 #ifdef DEBUG_ARCH_INIT
57 #define DPRINTF(fmt, ...) \
58 do { fprintf(stdout, "arch_init: " fmt, ## __VA_ARGS__); } while (0)
60 #define DPRINTF(fmt, ...) \
65 int graphic_width
= 1024;
66 int graphic_height
= 768;
67 int graphic_depth
= 8;
69 int graphic_width
= 800;
70 int graphic_height
= 600;
71 int graphic_depth
= 32;
75 #if defined(TARGET_ALPHA)
76 #define QEMU_ARCH QEMU_ARCH_ALPHA
77 #elif defined(TARGET_ARM)
78 #define QEMU_ARCH QEMU_ARCH_ARM
79 #elif defined(TARGET_CRIS)
80 #define QEMU_ARCH QEMU_ARCH_CRIS
81 #elif defined(TARGET_I386)
82 #define QEMU_ARCH QEMU_ARCH_I386
83 #elif defined(TARGET_M68K)
84 #define QEMU_ARCH QEMU_ARCH_M68K
85 #elif defined(TARGET_LM32)
86 #define QEMU_ARCH QEMU_ARCH_LM32
87 #elif defined(TARGET_MICROBLAZE)
88 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE
89 #elif defined(TARGET_MIPS)
90 #define QEMU_ARCH QEMU_ARCH_MIPS
91 #elif defined(TARGET_MOXIE)
92 #define QEMU_ARCH QEMU_ARCH_MOXIE
93 #elif defined(TARGET_OPENRISC)
94 #define QEMU_ARCH QEMU_ARCH_OPENRISC
95 #elif defined(TARGET_PPC)
96 #define QEMU_ARCH QEMU_ARCH_PPC
97 #elif defined(TARGET_S390X)
98 #define QEMU_ARCH QEMU_ARCH_S390X
99 #elif defined(TARGET_SH4)
100 #define QEMU_ARCH QEMU_ARCH_SH4
101 #elif defined(TARGET_SPARC)
102 #define QEMU_ARCH QEMU_ARCH_SPARC
103 #elif defined(TARGET_XTENSA)
104 #define QEMU_ARCH QEMU_ARCH_XTENSA
105 #elif defined(TARGET_UNICORE32)
106 #define QEMU_ARCH QEMU_ARCH_UNICORE32
109 const uint32_t arch_type
= QEMU_ARCH
;
110 static bool mig_throttle_on
;
111 static int dirty_rate_high_cnt
;
112 static void check_guest_throttling(void);
114 static uint64_t bitmap_sync_count
;
116 /***********************************************************/
117 /* ram save/restore */
119 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
120 #define RAM_SAVE_FLAG_COMPRESS 0x02
121 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
122 #define RAM_SAVE_FLAG_PAGE 0x08
123 #define RAM_SAVE_FLAG_EOS 0x10
124 #define RAM_SAVE_FLAG_CONTINUE 0x20
125 #define RAM_SAVE_FLAG_XBZRLE 0x40
126 /* 0x80 is reserved in migration.h start with 0x100 next */
128 static struct defconfig_file
{
129 const char *filename
;
130 /* Indicates it is an user config file (disabled by -no-user-config) */
132 } default_config_files
[] = {
133 { CONFIG_QEMU_CONFDIR
"/qemu.conf", true },
134 { CONFIG_QEMU_CONFDIR
"/target-" TARGET_NAME
".conf", true },
135 { NULL
}, /* end of list */
138 static const uint8_t ZERO_TARGET_PAGE
[TARGET_PAGE_SIZE
];
140 int qemu_read_default_config_files(bool userconfig
)
143 struct defconfig_file
*f
;
145 for (f
= default_config_files
; f
->filename
; f
++) {
146 if (!userconfig
&& f
->userconfig
) {
149 ret
= qemu_read_config_file(f
->filename
);
150 if (ret
< 0 && ret
!= -ENOENT
) {
158 static inline bool is_zero_range(uint8_t *p
, uint64_t size
)
160 return buffer_find_nonzero_offset(p
, size
) == size
;
163 /* struct contains XBZRLE cache and a static page
164 used by the compression */
166 /* buffer used for XBZRLE encoding */
167 uint8_t *encoded_buf
;
168 /* buffer for storing page content */
169 uint8_t *current_buf
;
170 /* Cache for XBZRLE, Protected by lock. */
175 /* buffer used for XBZRLE decoding */
176 static uint8_t *xbzrle_decoded_buf
;
178 static void XBZRLE_cache_lock(void)
180 if (migrate_use_xbzrle())
181 qemu_mutex_lock(&XBZRLE
.lock
);
184 static void XBZRLE_cache_unlock(void)
186 if (migrate_use_xbzrle())
187 qemu_mutex_unlock(&XBZRLE
.lock
);
191 * called from qmp_migrate_set_cache_size in main thread, possibly while
192 * a migration is in progress.
193 * A running migration maybe using the cache and might finish during this
194 * call, hence changes to the cache are protected by XBZRLE.lock().
196 int64_t xbzrle_cache_resize(int64_t new_size
)
198 PageCache
*new_cache
;
201 if (new_size
< TARGET_PAGE_SIZE
) {
207 if (XBZRLE
.cache
!= NULL
) {
208 if (pow2floor(new_size
) == migrate_xbzrle_cache_size()) {
211 new_cache
= cache_init(new_size
/ TARGET_PAGE_SIZE
,
214 error_report("Error creating cache");
219 cache_fini(XBZRLE
.cache
);
220 XBZRLE
.cache
= new_cache
;
224 ret
= pow2floor(new_size
);
226 XBZRLE_cache_unlock();
230 /* accounting for migration statistics */
231 typedef struct AccountingInfo
{
233 uint64_t skipped_pages
;
236 uint64_t xbzrle_bytes
;
237 uint64_t xbzrle_pages
;
238 uint64_t xbzrle_cache_miss
;
239 uint64_t xbzrle_overflows
;
242 static AccountingInfo acct_info
;
244 static void acct_clear(void)
246 memset(&acct_info
, 0, sizeof(acct_info
));
249 uint64_t dup_mig_bytes_transferred(void)
251 return acct_info
.dup_pages
* TARGET_PAGE_SIZE
;
254 uint64_t dup_mig_pages_transferred(void)
256 return acct_info
.dup_pages
;
259 uint64_t skipped_mig_bytes_transferred(void)
261 return acct_info
.skipped_pages
* TARGET_PAGE_SIZE
;
264 uint64_t skipped_mig_pages_transferred(void)
266 return acct_info
.skipped_pages
;
269 uint64_t norm_mig_bytes_transferred(void)
271 return acct_info
.norm_pages
* TARGET_PAGE_SIZE
;
274 uint64_t norm_mig_pages_transferred(void)
276 return acct_info
.norm_pages
;
279 uint64_t xbzrle_mig_bytes_transferred(void)
281 return acct_info
.xbzrle_bytes
;
284 uint64_t xbzrle_mig_pages_transferred(void)
286 return acct_info
.xbzrle_pages
;
289 uint64_t xbzrle_mig_pages_cache_miss(void)
291 return acct_info
.xbzrle_cache_miss
;
294 uint64_t xbzrle_mig_pages_overflow(void)
296 return acct_info
.xbzrle_overflows
;
299 static size_t save_block_hdr(QEMUFile
*f
, RAMBlock
*block
, ram_addr_t offset
,
304 qemu_put_be64(f
, offset
| cont
| flag
);
308 qemu_put_byte(f
, strlen(block
->idstr
));
309 qemu_put_buffer(f
, (uint8_t *)block
->idstr
,
310 strlen(block
->idstr
));
311 size
+= 1 + strlen(block
->idstr
);
316 /* This is the last block that we have visited serching for dirty pages
318 static RAMBlock
*last_seen_block
;
319 /* This is the last block from where we have sent data */
320 static RAMBlock
*last_sent_block
;
321 static ram_addr_t last_offset
;
322 static unsigned long *migration_bitmap
;
323 static uint64_t migration_dirty_pages
;
324 static uint32_t last_version
;
325 static bool ram_bulk_stage
;
327 /* Update the xbzrle cache to reflect a page that's been sent as all 0.
328 * The important thing is that a stale (not-yet-0'd) page be replaced
330 * As a bonus, if the page wasn't in the cache it gets added so that
331 * when a small write is made into the 0'd page it gets XBZRLE sent
333 static void xbzrle_cache_zero_page(ram_addr_t current_addr
)
335 if (ram_bulk_stage
|| !migrate_use_xbzrle()) {
339 /* We don't care if this fails to allocate a new cache page
340 * as long as it updated an old one */
341 cache_insert(XBZRLE
.cache
, current_addr
, ZERO_TARGET_PAGE
);
344 #define ENCODING_FLAG_XBZRLE 0x1
346 static int save_xbzrle_page(QEMUFile
*f
, uint8_t **current_data
,
347 ram_addr_t current_addr
, RAMBlock
*block
,
348 ram_addr_t offset
, int cont
, bool last_stage
)
350 int encoded_len
= 0, bytes_sent
= -1;
351 uint8_t *prev_cached_page
;
353 if (!cache_is_cached(XBZRLE
.cache
, current_addr
)) {
354 acct_info
.xbzrle_cache_miss
++;
356 if (cache_insert(XBZRLE
.cache
, current_addr
, *current_data
) == -1) {
359 /* update *current_data when the page has been
360 inserted into cache */
361 *current_data
= get_cached_data(XBZRLE
.cache
, current_addr
);
367 prev_cached_page
= get_cached_data(XBZRLE
.cache
, current_addr
);
369 /* save current buffer into memory */
370 memcpy(XBZRLE
.current_buf
, *current_data
, TARGET_PAGE_SIZE
);
372 /* XBZRLE encoding (if there is no overflow) */
373 encoded_len
= xbzrle_encode_buffer(prev_cached_page
, XBZRLE
.current_buf
,
374 TARGET_PAGE_SIZE
, XBZRLE
.encoded_buf
,
376 if (encoded_len
== 0) {
377 DPRINTF("Skipping unmodified page\n");
379 } else if (encoded_len
== -1) {
380 DPRINTF("Overflow\n");
381 acct_info
.xbzrle_overflows
++;
382 /* update data in the cache */
384 memcpy(prev_cached_page
, *current_data
, TARGET_PAGE_SIZE
);
385 *current_data
= prev_cached_page
;
390 /* we need to update the data in the cache, in order to get the same data */
392 memcpy(prev_cached_page
, XBZRLE
.current_buf
, TARGET_PAGE_SIZE
);
395 /* Send XBZRLE based compressed page */
396 bytes_sent
= save_block_hdr(f
, block
, offset
, cont
, RAM_SAVE_FLAG_XBZRLE
);
397 qemu_put_byte(f
, ENCODING_FLAG_XBZRLE
);
398 qemu_put_be16(f
, encoded_len
);
399 qemu_put_buffer(f
, XBZRLE
.encoded_buf
, encoded_len
);
400 bytes_sent
+= encoded_len
+ 1 + 2;
401 acct_info
.xbzrle_pages
++;
402 acct_info
.xbzrle_bytes
+= bytes_sent
;
408 ram_addr_t
migration_bitmap_find_and_reset_dirty(MemoryRegion
*mr
,
411 unsigned long base
= mr
->ram_addr
>> TARGET_PAGE_BITS
;
412 unsigned long nr
= base
+ (start
>> TARGET_PAGE_BITS
);
413 uint64_t mr_size
= TARGET_PAGE_ALIGN(memory_region_size(mr
));
414 unsigned long size
= base
+ (mr_size
>> TARGET_PAGE_BITS
);
418 if (ram_bulk_stage
&& nr
> base
) {
421 next
= find_next_bit(migration_bitmap
, size
, nr
);
425 clear_bit(next
, migration_bitmap
);
426 migration_dirty_pages
--;
428 return (next
- base
) << TARGET_PAGE_BITS
;
431 static inline bool migration_bitmap_set_dirty(ram_addr_t addr
)
434 int nr
= addr
>> TARGET_PAGE_BITS
;
436 ret
= test_and_set_bit(nr
, migration_bitmap
);
439 migration_dirty_pages
++;
444 static void migration_bitmap_sync_range(ram_addr_t start
, ram_addr_t length
)
447 unsigned long page
= BIT_WORD(start
>> TARGET_PAGE_BITS
);
449 /* start address is aligned at the start of a word? */
450 if (((page
* BITS_PER_LONG
) << TARGET_PAGE_BITS
) == start
) {
452 int nr
= BITS_TO_LONGS(length
>> TARGET_PAGE_BITS
);
453 unsigned long *src
= ram_list
.dirty_memory
[DIRTY_MEMORY_MIGRATION
];
455 for (k
= page
; k
< page
+ nr
; k
++) {
457 unsigned long new_dirty
;
458 new_dirty
= ~migration_bitmap
[k
];
459 migration_bitmap
[k
] |= src
[k
];
461 migration_dirty_pages
+= ctpopl(new_dirty
);
466 for (addr
= 0; addr
< length
; addr
+= TARGET_PAGE_SIZE
) {
467 if (cpu_physical_memory_get_dirty(start
+ addr
,
469 DIRTY_MEMORY_MIGRATION
)) {
470 cpu_physical_memory_reset_dirty(start
+ addr
,
472 DIRTY_MEMORY_MIGRATION
);
473 migration_bitmap_set_dirty(start
+ addr
);
480 /* Needs iothread lock! */
482 static void migration_bitmap_sync(void)
485 uint64_t num_dirty_pages_init
= migration_dirty_pages
;
486 MigrationState
*s
= migrate_get_current();
487 static int64_t start_time
;
488 static int64_t bytes_xfer_prev
;
489 static int64_t num_dirty_pages_period
;
491 int64_t bytes_xfer_now
;
495 if (!bytes_xfer_prev
) {
496 bytes_xfer_prev
= ram_bytes_transferred();
500 start_time
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
503 trace_migration_bitmap_sync_start();
504 address_space_sync_dirty_bitmap(&address_space_memory
);
506 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
) {
507 migration_bitmap_sync_range(block
->mr
->ram_addr
, block
->length
);
509 trace_migration_bitmap_sync_end(migration_dirty_pages
510 - num_dirty_pages_init
);
511 num_dirty_pages_period
+= migration_dirty_pages
- num_dirty_pages_init
;
512 end_time
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
514 /* more than 1 second = 1000 millisecons */
515 if (end_time
> start_time
+ 1000) {
516 if (migrate_auto_converge()) {
517 /* The following detection logic can be refined later. For now:
518 Check to see if the dirtied bytes is 50% more than the approx.
519 amount of bytes that just got transferred since the last time we
520 were in this routine. If that happens >N times (for now N==4)
521 we turn on the throttle down logic */
522 bytes_xfer_now
= ram_bytes_transferred();
523 if (s
->dirty_pages_rate
&&
524 (num_dirty_pages_period
* TARGET_PAGE_SIZE
>
525 (bytes_xfer_now
- bytes_xfer_prev
)/2) &&
526 (dirty_rate_high_cnt
++ > 4)) {
527 trace_migration_throttle();
528 mig_throttle_on
= true;
529 dirty_rate_high_cnt
= 0;
531 bytes_xfer_prev
= bytes_xfer_now
;
533 mig_throttle_on
= false;
535 s
->dirty_pages_rate
= num_dirty_pages_period
* 1000
536 / (end_time
- start_time
);
537 s
->dirty_bytes_rate
= s
->dirty_pages_rate
* TARGET_PAGE_SIZE
;
538 start_time
= end_time
;
539 num_dirty_pages_period
= 0;
544 * ram_save_block: Writes a page of memory to the stream f
546 * Returns: The number of bytes written.
547 * 0 means no dirty pages
550 static int ram_save_block(QEMUFile
*f
, bool last_stage
)
552 RAMBlock
*block
= last_seen_block
;
553 ram_addr_t offset
= last_offset
;
554 bool complete_round
= false;
557 ram_addr_t current_addr
;
560 block
= QTAILQ_FIRST(&ram_list
.blocks
);
564 offset
= migration_bitmap_find_and_reset_dirty(mr
, offset
);
565 if (complete_round
&& block
== last_seen_block
&&
566 offset
>= last_offset
) {
569 if (offset
>= block
->length
) {
571 block
= QTAILQ_NEXT(block
, next
);
573 block
= QTAILQ_FIRST(&ram_list
.blocks
);
574 complete_round
= true;
575 ram_bulk_stage
= false;
580 bool send_async
= true;
581 int cont
= (block
== last_sent_block
) ?
582 RAM_SAVE_FLAG_CONTINUE
: 0;
584 p
= memory_region_get_ram_ptr(mr
) + offset
;
586 /* In doubt sent page as normal */
588 ret
= ram_control_save_page(f
, block
->offset
,
589 offset
, TARGET_PAGE_SIZE
, &bytes_sent
);
593 current_addr
= block
->offset
+ offset
;
594 if (ret
!= RAM_SAVE_CONTROL_NOT_SUPP
) {
595 if (ret
!= RAM_SAVE_CONTROL_DELAYED
) {
596 if (bytes_sent
> 0) {
597 acct_info
.norm_pages
++;
598 } else if (bytes_sent
== 0) {
599 acct_info
.dup_pages
++;
602 } else if (is_zero_range(p
, TARGET_PAGE_SIZE
)) {
603 acct_info
.dup_pages
++;
604 bytes_sent
= save_block_hdr(f
, block
, offset
, cont
,
605 RAM_SAVE_FLAG_COMPRESS
);
608 /* Must let xbzrle know, otherwise a previous (now 0'd) cached
609 * page would be stale
611 xbzrle_cache_zero_page(current_addr
);
612 } else if (!ram_bulk_stage
&& migrate_use_xbzrle()) {
613 bytes_sent
= save_xbzrle_page(f
, &p
, current_addr
, block
,
614 offset
, cont
, last_stage
);
616 /* Can't send this cached data async, since the cache page
617 * might get updated before it gets to the wire
623 /* XBZRLE overflow or normal page */
624 if (bytes_sent
== -1) {
625 bytes_sent
= save_block_hdr(f
, block
, offset
, cont
, RAM_SAVE_FLAG_PAGE
);
627 qemu_put_buffer_async(f
, p
, TARGET_PAGE_SIZE
);
629 qemu_put_buffer(f
, p
, TARGET_PAGE_SIZE
);
631 bytes_sent
+= TARGET_PAGE_SIZE
;
632 acct_info
.norm_pages
++;
635 XBZRLE_cache_unlock();
636 /* if page is unmodified, continue to the next */
637 if (bytes_sent
> 0) {
638 last_sent_block
= block
;
643 last_seen_block
= block
;
644 last_offset
= offset
;
649 static uint64_t bytes_transferred
;
651 void acct_update_position(QEMUFile
*f
, size_t size
, bool zero
)
653 uint64_t pages
= size
/ TARGET_PAGE_SIZE
;
655 acct_info
.dup_pages
+= pages
;
657 acct_info
.norm_pages
+= pages
;
658 bytes_transferred
+= size
;
659 qemu_update_position(f
, size
);
663 static ram_addr_t
ram_save_remaining(void)
665 return migration_dirty_pages
;
668 uint64_t ram_bytes_remaining(void)
670 return ram_save_remaining() * TARGET_PAGE_SIZE
;
673 uint64_t ram_bytes_transferred(void)
675 return bytes_transferred
;
678 uint64_t ram_bytes_total(void)
683 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
)
684 total
+= block
->length
;
689 void free_xbzrle_decoded_buf(void)
691 g_free(xbzrle_decoded_buf
);
692 xbzrle_decoded_buf
= NULL
;
695 static void migration_end(void)
697 if (migration_bitmap
) {
698 memory_global_dirty_log_stop();
699 g_free(migration_bitmap
);
700 migration_bitmap
= NULL
;
705 cache_fini(XBZRLE
.cache
);
706 g_free(XBZRLE
.cache
);
707 g_free(XBZRLE
.encoded_buf
);
708 g_free(XBZRLE
.current_buf
);
710 XBZRLE
.encoded_buf
= NULL
;
711 XBZRLE
.current_buf
= NULL
;
713 XBZRLE_cache_unlock();
716 static void ram_migration_cancel(void *opaque
)
721 static void reset_ram_globals(void)
723 last_seen_block
= NULL
;
724 last_sent_block
= NULL
;
726 last_version
= ram_list
.version
;
727 ram_bulk_stage
= true;
730 #define MAX_WAIT 50 /* ms, half buffered_file limit */
732 static int ram_save_setup(QEMUFile
*f
, void *opaque
)
735 int64_t ram_bitmap_pages
; /* Size of bitmap in pages, including gaps */
737 mig_throttle_on
= false;
738 dirty_rate_high_cnt
= 0;
739 bitmap_sync_count
= 0;
741 if (migrate_use_xbzrle()) {
743 XBZRLE
.cache
= cache_init(migrate_xbzrle_cache_size() /
747 XBZRLE_cache_unlock();
748 error_report("Error creating cache");
751 XBZRLE_cache_unlock();
753 /* We prefer not to abort if there is no memory */
754 XBZRLE
.encoded_buf
= g_try_malloc0(TARGET_PAGE_SIZE
);
755 if (!XBZRLE
.encoded_buf
) {
756 error_report("Error allocating encoded_buf");
760 XBZRLE
.current_buf
= g_try_malloc(TARGET_PAGE_SIZE
);
761 if (!XBZRLE
.current_buf
) {
762 error_report("Error allocating current_buf");
763 g_free(XBZRLE
.encoded_buf
);
764 XBZRLE
.encoded_buf
= NULL
;
771 qemu_mutex_lock_iothread();
772 qemu_mutex_lock_ramlist();
773 bytes_transferred
= 0;
776 ram_bitmap_pages
= last_ram_offset() >> TARGET_PAGE_BITS
;
777 migration_bitmap
= bitmap_new(ram_bitmap_pages
);
778 bitmap_set(migration_bitmap
, 0, ram_bitmap_pages
);
781 * Count the total number of pages used by ram blocks not including any
782 * gaps due to alignment or unplugs.
784 migration_dirty_pages
= 0;
785 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
) {
786 uint64_t block_pages
;
788 block_pages
= block
->length
>> TARGET_PAGE_BITS
;
789 migration_dirty_pages
+= block_pages
;
792 memory_global_dirty_log_start();
793 migration_bitmap_sync();
794 qemu_mutex_unlock_iothread();
796 qemu_put_be64(f
, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE
);
798 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
) {
799 qemu_put_byte(f
, strlen(block
->idstr
));
800 qemu_put_buffer(f
, (uint8_t *)block
->idstr
, strlen(block
->idstr
));
801 qemu_put_be64(f
, block
->length
);
804 qemu_mutex_unlock_ramlist();
806 ram_control_before_iterate(f
, RAM_CONTROL_SETUP
);
807 ram_control_after_iterate(f
, RAM_CONTROL_SETUP
);
809 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
814 static int ram_save_iterate(QEMUFile
*f
, void *opaque
)
821 qemu_mutex_lock_ramlist();
823 if (ram_list
.version
!= last_version
) {
827 ram_control_before_iterate(f
, RAM_CONTROL_ROUND
);
829 t0
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
);
831 while ((ret
= qemu_file_rate_limit(f
)) == 0) {
834 bytes_sent
= ram_save_block(f
, false);
835 /* no more blocks to sent */
836 if (bytes_sent
== 0) {
839 total_sent
+= bytes_sent
;
840 acct_info
.iterations
++;
841 check_guest_throttling();
842 /* we want to check in the 1st loop, just in case it was the 1st time
843 and we had to sync the dirty bitmap.
844 qemu_get_clock_ns() is a bit expensive, so we only check each some
848 uint64_t t1
= (qemu_clock_get_ns(QEMU_CLOCK_REALTIME
) - t0
) / 1000000;
850 DPRINTF("big wait: %" PRIu64
" milliseconds, %d iterations\n",
858 qemu_mutex_unlock_ramlist();
861 * Must occur before EOS (or any QEMUFile operation)
862 * because of RDMA protocol.
864 ram_control_after_iterate(f
, RAM_CONTROL_ROUND
);
866 bytes_transferred
+= total_sent
;
869 * Do not count these 8 bytes into total_sent, so that we can
870 * return 0 if no page had been dirtied.
872 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
873 bytes_transferred
+= 8;
875 ret
= qemu_file_get_error(f
);
883 static int ram_save_complete(QEMUFile
*f
, void *opaque
)
885 qemu_mutex_lock_ramlist();
886 migration_bitmap_sync();
888 ram_control_before_iterate(f
, RAM_CONTROL_FINISH
);
890 /* try transferring iterative blocks of memory */
892 /* flush all remaining blocks regardless of rate limiting */
896 bytes_sent
= ram_save_block(f
, true);
897 /* no more blocks to sent */
898 if (bytes_sent
== 0) {
901 bytes_transferred
+= bytes_sent
;
904 ram_control_after_iterate(f
, RAM_CONTROL_FINISH
);
907 qemu_mutex_unlock_ramlist();
908 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
913 static uint64_t ram_save_pending(QEMUFile
*f
, void *opaque
, uint64_t max_size
)
915 uint64_t remaining_size
;
917 remaining_size
= ram_save_remaining() * TARGET_PAGE_SIZE
;
919 if (remaining_size
< max_size
) {
920 qemu_mutex_lock_iothread();
921 migration_bitmap_sync();
922 qemu_mutex_unlock_iothread();
923 remaining_size
= ram_save_remaining() * TARGET_PAGE_SIZE
;
925 return remaining_size
;
928 static int load_xbzrle(QEMUFile
*f
, ram_addr_t addr
, void *host
)
934 if (!xbzrle_decoded_buf
) {
935 xbzrle_decoded_buf
= g_malloc(TARGET_PAGE_SIZE
);
938 /* extract RLE header */
939 xh_flags
= qemu_get_byte(f
);
940 xh_len
= qemu_get_be16(f
);
942 if (xh_flags
!= ENCODING_FLAG_XBZRLE
) {
943 fprintf(stderr
, "Failed to load XBZRLE page - wrong compression!\n");
947 if (xh_len
> TARGET_PAGE_SIZE
) {
948 fprintf(stderr
, "Failed to load XBZRLE page - len overflow!\n");
951 /* load data and decode */
952 qemu_get_buffer(f
, xbzrle_decoded_buf
, xh_len
);
955 ret
= xbzrle_decode_buffer(xbzrle_decoded_buf
, xh_len
, host
,
958 fprintf(stderr
, "Failed to load XBZRLE page - decode error!\n");
960 } else if (ret
> TARGET_PAGE_SIZE
) {
961 fprintf(stderr
, "Failed to load XBZRLE page - size %d exceeds %d!\n",
962 ret
, TARGET_PAGE_SIZE
);
969 static inline void *host_from_stream_offset(QEMUFile
*f
,
973 static RAMBlock
*block
= NULL
;
977 if (flags
& RAM_SAVE_FLAG_CONTINUE
) {
979 fprintf(stderr
, "Ack, bad migration stream!\n");
983 return memory_region_get_ram_ptr(block
->mr
) + offset
;
986 len
= qemu_get_byte(f
);
987 qemu_get_buffer(f
, (uint8_t *)id
, len
);
990 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
) {
991 if (!strncmp(id
, block
->idstr
, sizeof(id
)))
992 return memory_region_get_ram_ptr(block
->mr
) + offset
;
995 fprintf(stderr
, "Can't find block %s!\n", id
);
1000 * If a page (or a whole RDMA chunk) has been
1001 * determined to be zero, then zap it.
1003 void ram_handle_compressed(void *host
, uint8_t ch
, uint64_t size
)
1005 if (ch
!= 0 || !is_zero_range(host
, size
)) {
1006 memset(host
, ch
, size
);
1010 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
1015 static uint64_t seq_iter
;
1019 if (version_id
!= 4) {
1024 addr
= qemu_get_be64(f
);
1026 flags
= addr
& ~TARGET_PAGE_MASK
;
1027 addr
&= TARGET_PAGE_MASK
;
1029 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
1030 /* Synchronize RAM block list */
1033 ram_addr_t total_ram_bytes
= addr
;
1035 while (total_ram_bytes
) {
1039 len
= qemu_get_byte(f
);
1040 qemu_get_buffer(f
, (uint8_t *)id
, len
);
1042 length
= qemu_get_be64(f
);
1044 QTAILQ_FOREACH(block
, &ram_list
.blocks
, next
) {
1045 if (!strncmp(id
, block
->idstr
, sizeof(id
))) {
1046 if (block
->length
!= length
) {
1048 "Length mismatch: %s: " RAM_ADDR_FMT
1049 " in != " RAM_ADDR_FMT
"\n", id
, length
,
1059 fprintf(stderr
, "Unknown ramblock \"%s\", cannot "
1060 "accept migration\n", id
);
1065 total_ram_bytes
-= length
;
1069 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
1073 host
= host_from_stream_offset(f
, addr
, flags
);
1078 ch
= qemu_get_byte(f
);
1079 ram_handle_compressed(host
, ch
, TARGET_PAGE_SIZE
);
1080 } else if (flags
& RAM_SAVE_FLAG_PAGE
) {
1083 host
= host_from_stream_offset(f
, addr
, flags
);
1088 qemu_get_buffer(f
, host
, TARGET_PAGE_SIZE
);
1089 } else if (flags
& RAM_SAVE_FLAG_XBZRLE
) {
1090 void *host
= host_from_stream_offset(f
, addr
, flags
);
1095 if (load_xbzrle(f
, addr
, host
) < 0) {
1099 } else if (flags
& RAM_SAVE_FLAG_HOOK
) {
1100 ram_control_load_hook(f
, flags
);
1102 error
= qemu_file_get_error(f
);
1107 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
1110 DPRINTF("Completed load of VM with exit code %d seq iteration "
1111 "%" PRIu64
"\n", ret
, seq_iter
);
1115 static SaveVMHandlers savevm_ram_handlers
= {
1116 .save_live_setup
= ram_save_setup
,
1117 .save_live_iterate
= ram_save_iterate
,
1118 .save_live_complete
= ram_save_complete
,
1119 .save_live_pending
= ram_save_pending
,
1120 .load_state
= ram_load
,
1121 .cancel
= ram_migration_cancel
,
1124 void ram_mig_init(void)
1126 qemu_mutex_init(&XBZRLE
.lock
);
1127 register_savevm_live(NULL
, "ram", 0, 4, &savevm_ram_handlers
, NULL
);
1136 int (*init_isa
) (ISABus
*bus
);
1137 int (*init_pci
) (PCIBus
*bus
);
1141 static struct soundhw soundhw
[9];
1142 static int soundhw_count
;
1144 void isa_register_soundhw(const char *name
, const char *descr
,
1145 int (*init_isa
)(ISABus
*bus
))
1147 assert(soundhw_count
< ARRAY_SIZE(soundhw
) - 1);
1148 soundhw
[soundhw_count
].name
= name
;
1149 soundhw
[soundhw_count
].descr
= descr
;
1150 soundhw
[soundhw_count
].isa
= 1;
1151 soundhw
[soundhw_count
].init
.init_isa
= init_isa
;
1155 void pci_register_soundhw(const char *name
, const char *descr
,
1156 int (*init_pci
)(PCIBus
*bus
))
1158 assert(soundhw_count
< ARRAY_SIZE(soundhw
) - 1);
1159 soundhw
[soundhw_count
].name
= name
;
1160 soundhw
[soundhw_count
].descr
= descr
;
1161 soundhw
[soundhw_count
].isa
= 0;
1162 soundhw
[soundhw_count
].init
.init_pci
= init_pci
;
1166 void select_soundhw(const char *optarg
)
1170 if (is_help_option(optarg
)) {
1173 if (soundhw_count
) {
1174 printf("Valid sound card names (comma separated):\n");
1175 for (c
= soundhw
; c
->name
; ++c
) {
1176 printf ("%-11s %s\n", c
->name
, c
->descr
);
1178 printf("\n-soundhw all will enable all of the above\n");
1180 printf("Machine has no user-selectable audio hardware "
1181 "(it may or may not have always-present audio hardware).\n");
1183 exit(!is_help_option(optarg
));
1191 if (!strcmp(optarg
, "all")) {
1192 for (c
= soundhw
; c
->name
; ++c
) {
1201 l
= !e
? strlen(p
) : (size_t) (e
- p
);
1203 for (c
= soundhw
; c
->name
; ++c
) {
1204 if (!strncmp(c
->name
, p
, l
) && !c
->name
[l
]) {
1213 "Unknown sound card name (too big to show)\n");
1216 fprintf(stderr
, "Unknown sound card name `%.*s'\n",
1221 p
+= l
+ (e
!= NULL
);
1225 goto show_valid_cards
;
1230 void audio_init(void)
1233 ISABus
*isa_bus
= (ISABus
*) object_resolve_path_type("", TYPE_ISA_BUS
, NULL
);
1234 PCIBus
*pci_bus
= (PCIBus
*) object_resolve_path_type("", TYPE_PCI_BUS
, NULL
);
1236 for (c
= soundhw
; c
->name
; ++c
) {
1240 fprintf(stderr
, "ISA bus not available for %s\n", c
->name
);
1243 c
->init
.init_isa(isa_bus
);
1246 fprintf(stderr
, "PCI bus not available for %s\n", c
->name
);
1249 c
->init
.init_pci(pci_bus
);
1255 int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
1259 if (strlen(str
) != 36) {
1263 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
1264 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
1265 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14],
1274 void do_acpitable_option(const QemuOpts
*opts
)
1279 acpi_table_add(opts
, &err
);
1281 error_report("Wrong acpi table provided: %s",
1282 error_get_pretty(err
));
1289 void do_smbios_option(QemuOpts
*opts
)
1292 smbios_entry_add(opts
);
1296 void cpudef_init(void)
1298 #if defined(cpudef_setup)
1299 cpudef_setup(); /* parse cpu definitions in target config file */
1303 int tcg_available(void)
1308 int kvm_available(void)
1317 int xen_available(void)
1327 TargetInfo
*qmp_query_target(Error
**errp
)
1329 TargetInfo
*info
= g_malloc0(sizeof(*info
));
1331 info
->arch
= g_strdup(TARGET_NAME
);
1336 /* Stub function that's gets run on the vcpu when its brought out of the
1337 VM to run inside qemu via async_run_on_cpu()*/
1338 static void mig_sleep_cpu(void *opq
)
1340 qemu_mutex_unlock_iothread();
1342 qemu_mutex_lock_iothread();
1345 /* To reduce the dirty rate explicitly disallow the VCPUs from spending
1346 much time in the VM. The migration thread will try to catchup.
1347 Workload will experience a performance drop.
1349 static void mig_throttle_guest_down(void)
1353 qemu_mutex_lock_iothread();
1355 async_run_on_cpu(cpu
, mig_sleep_cpu
, NULL
);
1357 qemu_mutex_unlock_iothread();
1360 static void check_guest_throttling(void)
1365 if (!mig_throttle_on
) {
1370 t0
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
);
1374 t1
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
);
1376 /* If it has been more than 40 ms since the last time the guest
1377 * was throttled then do it again.
1379 if (40 < (t1
-t0
)/1000000) {
1380 mig_throttle_guest_down();