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> 26 #include <stdlib.h> 27 #ifndef _WIN32 28 #include <sys/types.h> 29 #include <sys/mman.h> 30 #endif 31 #include "config.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/pc.h" 39 #include "hw/pci/pci.h" 40 #include "hw/audiodev.h" 41 #include "sysemu/kvm.h" 42 #include "migration/migration.h" 43 #include "exec/gdbstub.h" 44 #include "hw/smbios.h" 45 #include "exec/address-spaces.h" 46 #include "hw/pcspk.h" 47 #include "migration/page_cache.h" 48 #include "qemu/config-file.h" 49 #include "qmp-commands.h" 50 #include "trace.h" 51 #include "exec/cpu-all.h" 52 53 #ifdef DEBUG_ARCH_INIT 54 #define DPRINTF(fmt, ...) \ 55 do { fprintf(stdout, "arch_init: " fmt, ## __VA_ARGS__); } while (0) 56 #else 57 #define DPRINTF(fmt, ...) \ 58 do { } while (0) 59 #endif 60 61 #ifdef TARGET_SPARC 62 int graphic_width = 1024; 63 int graphic_height = 768; 64 int graphic_depth = 8; 65 #else 66 int graphic_width = 800; 67 int graphic_height = 600; 68 int graphic_depth = 15; 69 #endif 70 71 72 #if defined(TARGET_ALPHA) 73 #define QEMU_ARCH QEMU_ARCH_ALPHA 74 #elif defined(TARGET_ARM) 75 #define QEMU_ARCH QEMU_ARCH_ARM 76 #elif defined(TARGET_CRIS) 77 #define QEMU_ARCH QEMU_ARCH_CRIS 78 #elif defined(TARGET_I386) 79 #define QEMU_ARCH QEMU_ARCH_I386 80 #elif defined(TARGET_M68K) 81 #define QEMU_ARCH QEMU_ARCH_M68K 82 #elif defined(TARGET_LM32) 83 #define QEMU_ARCH QEMU_ARCH_LM32 84 #elif defined(TARGET_MICROBLAZE) 85 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE 86 #elif defined(TARGET_MIPS) 87 #define QEMU_ARCH QEMU_ARCH_MIPS 88 #elif defined(TARGET_MOXIE) 89 #define QEMU_ARCH QEMU_ARCH_MOXIE 90 #elif defined(TARGET_OPENRISC) 91 #define QEMU_ARCH QEMU_ARCH_OPENRISC 92 #elif defined(TARGET_PPC) 93 #define QEMU_ARCH QEMU_ARCH_PPC 94 #elif defined(TARGET_S390X) 95 #define QEMU_ARCH QEMU_ARCH_S390X 96 #elif defined(TARGET_SH4) 97 #define QEMU_ARCH QEMU_ARCH_SH4 98 #elif defined(TARGET_SPARC) 99 #define QEMU_ARCH QEMU_ARCH_SPARC 100 #elif defined(TARGET_XTENSA) 101 #define QEMU_ARCH QEMU_ARCH_XTENSA 102 #elif defined(TARGET_UNICORE32) 103 #define QEMU_ARCH QEMU_ARCH_UNICORE32 104 #endif 105 106 const uint32_t arch_type = QEMU_ARCH; 107 108 /***********************************************************/ 109 /* ram save/restore */ 110 111 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */ 112 #define RAM_SAVE_FLAG_COMPRESS 0x02 113 #define RAM_SAVE_FLAG_MEM_SIZE 0x04 114 #define RAM_SAVE_FLAG_PAGE 0x08 115 #define RAM_SAVE_FLAG_EOS 0x10 116 #define RAM_SAVE_FLAG_CONTINUE 0x20 117 #define RAM_SAVE_FLAG_XBZRLE 0x40 118 119 120 static struct defconfig_file { 121 const char *filename; 122 /* Indicates it is an user config file (disabled by -no-user-config) */ 123 bool userconfig; 124 } default_config_files[] = { 125 { CONFIG_QEMU_CONFDIR "/qemu.conf", true }, 126 { CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", true }, 127 { NULL }, /* end of list */ 128 }; 129 130 131 int qemu_read_default_config_files(bool userconfig) 132 { 133 int ret; 134 struct defconfig_file *f; 135 136 for (f = default_config_files; f->filename; f++) { 137 if (!userconfig && f->userconfig) { 138 continue; 139 } 140 ret = qemu_read_config_file(f->filename); 141 if (ret < 0 && ret != -ENOENT) { 142 return ret; 143 } 144 } 145 146 return 0; 147 } 148 149 static inline bool is_zero_page(uint8_t *p) 150 { 151 return buffer_find_nonzero_offset(p, TARGET_PAGE_SIZE) == 152 TARGET_PAGE_SIZE; 153 } 154 155 /* struct contains XBZRLE cache and a static page 156 used by the compression */ 157 static struct { 158 /* buffer used for XBZRLE encoding */ 159 uint8_t *encoded_buf; 160 /* buffer for storing page content */ 161 uint8_t *current_buf; 162 /* buffer used for XBZRLE decoding */ 163 uint8_t *decoded_buf; 164 /* Cache for XBZRLE */ 165 PageCache *cache; 166 } XBZRLE = { 167 .encoded_buf = NULL, 168 .current_buf = NULL, 169 .decoded_buf = NULL, 170 .cache = NULL, 171 }; 172 173 174 int64_t xbzrle_cache_resize(int64_t new_size) 175 { 176 if (XBZRLE.cache != NULL) { 177 return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) * 178 TARGET_PAGE_SIZE; 179 } 180 return pow2floor(new_size); 181 } 182 183 /* accounting for migration statistics */ 184 typedef struct AccountingInfo { 185 uint64_t dup_pages; 186 uint64_t norm_pages; 187 uint64_t iterations; 188 uint64_t xbzrle_bytes; 189 uint64_t xbzrle_pages; 190 uint64_t xbzrle_cache_miss; 191 uint64_t xbzrle_overflows; 192 } AccountingInfo; 193 194 static AccountingInfo acct_info; 195 196 static void acct_clear(void) 197 { 198 memset(&acct_info, 0, sizeof(acct_info)); 199 } 200 201 uint64_t dup_mig_bytes_transferred(void) 202 { 203 return acct_info.dup_pages * TARGET_PAGE_SIZE; 204 } 205 206 uint64_t dup_mig_pages_transferred(void) 207 { 208 return acct_info.dup_pages; 209 } 210 211 uint64_t norm_mig_bytes_transferred(void) 212 { 213 return acct_info.norm_pages * TARGET_PAGE_SIZE; 214 } 215 216 uint64_t norm_mig_pages_transferred(void) 217 { 218 return acct_info.norm_pages; 219 } 220 221 uint64_t xbzrle_mig_bytes_transferred(void) 222 { 223 return acct_info.xbzrle_bytes; 224 } 225 226 uint64_t xbzrle_mig_pages_transferred(void) 227 { 228 return acct_info.xbzrle_pages; 229 } 230 231 uint64_t xbzrle_mig_pages_cache_miss(void) 232 { 233 return acct_info.xbzrle_cache_miss; 234 } 235 236 uint64_t xbzrle_mig_pages_overflow(void) 237 { 238 return acct_info.xbzrle_overflows; 239 } 240 241 static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset, 242 int cont, int flag) 243 { 244 size_t size; 245 246 qemu_put_be64(f, offset | cont | flag); 247 size = 8; 248 249 if (!cont) { 250 qemu_put_byte(f, strlen(block->idstr)); 251 qemu_put_buffer(f, (uint8_t *)block->idstr, 252 strlen(block->idstr)); 253 size += 1 + strlen(block->idstr); 254 } 255 return size; 256 } 257 258 #define ENCODING_FLAG_XBZRLE 0x1 259 260 static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data, 261 ram_addr_t current_addr, RAMBlock *block, 262 ram_addr_t offset, int cont, bool last_stage) 263 { 264 int encoded_len = 0, bytes_sent = -1; 265 uint8_t *prev_cached_page; 266 267 if (!cache_is_cached(XBZRLE.cache, current_addr)) { 268 if (!last_stage) { 269 cache_insert(XBZRLE.cache, current_addr, current_data); 270 } 271 acct_info.xbzrle_cache_miss++; 272 return -1; 273 } 274 275 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr); 276 277 /* save current buffer into memory */ 278 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE); 279 280 /* XBZRLE encoding (if there is no overflow) */ 281 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf, 282 TARGET_PAGE_SIZE, XBZRLE.encoded_buf, 283 TARGET_PAGE_SIZE); 284 if (encoded_len == 0) { 285 DPRINTF("Skipping unmodified page\n"); 286 return 0; 287 } else if (encoded_len == -1) { 288 DPRINTF("Overflow\n"); 289 acct_info.xbzrle_overflows++; 290 /* update data in the cache */ 291 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE); 292 return -1; 293 } 294 295 /* we need to update the data in the cache, in order to get the same data */ 296 if (!last_stage) { 297 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE); 298 } 299 300 /* Send XBZRLE based compressed page */ 301 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE); 302 qemu_put_byte(f, ENCODING_FLAG_XBZRLE); 303 qemu_put_be16(f, encoded_len); 304 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len); 305 bytes_sent += encoded_len + 1 + 2; 306 acct_info.xbzrle_pages++; 307 acct_info.xbzrle_bytes += bytes_sent; 308 309 return bytes_sent; 310 } 311 312 313 /* This is the last block that we have visited serching for dirty pages 314 */ 315 static RAMBlock *last_seen_block; 316 /* This is the last block from where we have sent data */ 317 static RAMBlock *last_sent_block; 318 static ram_addr_t last_offset; 319 static unsigned long *migration_bitmap; 320 static uint64_t migration_dirty_pages; 321 static uint32_t last_version; 322 323 static inline 324 ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr, 325 ram_addr_t start) 326 { 327 unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS; 328 unsigned long nr = base + (start >> TARGET_PAGE_BITS); 329 unsigned long size = base + (int128_get64(mr->size) >> TARGET_PAGE_BITS); 330 331 unsigned long next = find_next_bit(migration_bitmap, size, nr); 332 333 if (next < size) { 334 clear_bit(next, migration_bitmap); 335 migration_dirty_pages--; 336 } 337 return (next - base) << TARGET_PAGE_BITS; 338 } 339 340 static inline bool migration_bitmap_set_dirty(MemoryRegion *mr, 341 ram_addr_t offset) 342 { 343 bool ret; 344 int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS; 345 346 ret = test_and_set_bit(nr, migration_bitmap); 347 348 if (!ret) { 349 migration_dirty_pages++; 350 } 351 return ret; 352 } 353 354 /* Needs iothread lock! */ 355 356 static void migration_bitmap_sync(void) 357 { 358 RAMBlock *block; 359 ram_addr_t addr; 360 uint64_t num_dirty_pages_init = migration_dirty_pages; 361 MigrationState *s = migrate_get_current(); 362 static int64_t start_time; 363 static int64_t num_dirty_pages_period; 364 int64_t end_time; 365 366 if (!start_time) { 367 start_time = qemu_get_clock_ms(rt_clock); 368 } 369 370 trace_migration_bitmap_sync_start(); 371 memory_global_sync_dirty_bitmap(get_system_memory()); 372 373 QTAILQ_FOREACH(block, &ram_list.blocks, next) { 374 for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) { 375 if (memory_region_test_and_clear_dirty(block->mr, 376 addr, TARGET_PAGE_SIZE, 377 DIRTY_MEMORY_MIGRATION)) { 378 migration_bitmap_set_dirty(block->mr, addr); 379 } 380 } 381 } 382 trace_migration_bitmap_sync_end(migration_dirty_pages 383 - num_dirty_pages_init); 384 num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init; 385 end_time = qemu_get_clock_ms(rt_clock); 386 387 /* more than 1 second = 1000 millisecons */ 388 if (end_time > start_time + 1000) { 389 s->dirty_pages_rate = num_dirty_pages_period * 1000 390 / (end_time - start_time); 391 s->dirty_bytes_rate = s->dirty_pages_rate * TARGET_PAGE_SIZE; 392 start_time = end_time; 393 num_dirty_pages_period = 0; 394 } 395 } 396 397 /* 398 * ram_save_block: Writes a page of memory to the stream f 399 * 400 * Returns: The number of bytes written. 401 * 0 means no dirty pages 402 */ 403 404 static int ram_save_block(QEMUFile *f, bool last_stage) 405 { 406 RAMBlock *block = last_seen_block; 407 ram_addr_t offset = last_offset; 408 bool complete_round = false; 409 int bytes_sent = 0; 410 MemoryRegion *mr; 411 ram_addr_t current_addr; 412 413 if (!block) 414 block = QTAILQ_FIRST(&ram_list.blocks); 415 416 while (true) { 417 mr = block->mr; 418 offset = migration_bitmap_find_and_reset_dirty(mr, offset); 419 if (complete_round && block == last_seen_block && 420 offset >= last_offset) { 421 break; 422 } 423 if (offset >= block->length) { 424 offset = 0; 425 block = QTAILQ_NEXT(block, next); 426 if (!block) { 427 block = QTAILQ_FIRST(&ram_list.blocks); 428 complete_round = true; 429 } 430 } else { 431 uint8_t *p; 432 int cont = (block == last_sent_block) ? 433 RAM_SAVE_FLAG_CONTINUE : 0; 434 435 p = memory_region_get_ram_ptr(mr) + offset; 436 437 /* In doubt sent page as normal */ 438 bytes_sent = -1; 439 if (is_zero_page(p)) { 440 acct_info.dup_pages++; 441 bytes_sent = save_block_hdr(f, block, offset, cont, 442 RAM_SAVE_FLAG_COMPRESS); 443 qemu_put_byte(f, 0); 444 bytes_sent++; 445 } else if (migrate_use_xbzrle()) { 446 current_addr = block->offset + offset; 447 bytes_sent = save_xbzrle_page(f, p, current_addr, block, 448 offset, cont, last_stage); 449 if (!last_stage) { 450 p = get_cached_data(XBZRLE.cache, current_addr); 451 } 452 } 453 454 /* XBZRLE overflow or normal page */ 455 if (bytes_sent == -1) { 456 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE); 457 qemu_put_buffer(f, p, TARGET_PAGE_SIZE); 458 bytes_sent += TARGET_PAGE_SIZE; 459 acct_info.norm_pages++; 460 } 461 462 /* if page is unmodified, continue to the next */ 463 if (bytes_sent > 0) { 464 last_sent_block = block; 465 break; 466 } 467 } 468 } 469 last_seen_block = block; 470 last_offset = offset; 471 472 return bytes_sent; 473 } 474 475 static uint64_t bytes_transferred; 476 477 static ram_addr_t ram_save_remaining(void) 478 { 479 return migration_dirty_pages; 480 } 481 482 uint64_t ram_bytes_remaining(void) 483 { 484 return ram_save_remaining() * TARGET_PAGE_SIZE; 485 } 486 487 uint64_t ram_bytes_transferred(void) 488 { 489 return bytes_transferred; 490 } 491 492 uint64_t ram_bytes_total(void) 493 { 494 RAMBlock *block; 495 uint64_t total = 0; 496 497 QTAILQ_FOREACH(block, &ram_list.blocks, next) 498 total += block->length; 499 500 return total; 501 } 502 503 static void migration_end(void) 504 { 505 if (migration_bitmap) { 506 memory_global_dirty_log_stop(); 507 g_free(migration_bitmap); 508 migration_bitmap = NULL; 509 } 510 511 if (XBZRLE.cache) { 512 cache_fini(XBZRLE.cache); 513 g_free(XBZRLE.cache); 514 g_free(XBZRLE.encoded_buf); 515 g_free(XBZRLE.current_buf); 516 g_free(XBZRLE.decoded_buf); 517 XBZRLE.cache = NULL; 518 } 519 } 520 521 static void ram_migration_cancel(void *opaque) 522 { 523 migration_end(); 524 } 525 526 static void reset_ram_globals(void) 527 { 528 last_seen_block = NULL; 529 last_sent_block = NULL; 530 last_offset = 0; 531 last_version = ram_list.version; 532 } 533 534 #define MAX_WAIT 50 /* ms, half buffered_file limit */ 535 536 static int ram_save_setup(QEMUFile *f, void *opaque) 537 { 538 RAMBlock *block; 539 int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS; 540 541 migration_bitmap = bitmap_new(ram_pages); 542 bitmap_set(migration_bitmap, 0, ram_pages); 543 migration_dirty_pages = ram_pages; 544 545 if (migrate_use_xbzrle()) { 546 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() / 547 TARGET_PAGE_SIZE, 548 TARGET_PAGE_SIZE); 549 if (!XBZRLE.cache) { 550 DPRINTF("Error creating cache\n"); 551 return -1; 552 } 553 XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE); 554 XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE); 555 acct_clear(); 556 } 557 558 qemu_mutex_lock_iothread(); 559 qemu_mutex_lock_ramlist(); 560 bytes_transferred = 0; 561 reset_ram_globals(); 562 563 memory_global_dirty_log_start(); 564 migration_bitmap_sync(); 565 qemu_mutex_unlock_iothread(); 566 567 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE); 568 569 QTAILQ_FOREACH(block, &ram_list.blocks, next) { 570 qemu_put_byte(f, strlen(block->idstr)); 571 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr)); 572 qemu_put_be64(f, block->length); 573 } 574 575 qemu_mutex_unlock_ramlist(); 576 qemu_put_be64(f, RAM_SAVE_FLAG_EOS); 577 578 return 0; 579 } 580 581 static int ram_save_iterate(QEMUFile *f, void *opaque) 582 { 583 int ret; 584 int i; 585 int64_t t0; 586 int total_sent = 0; 587 588 qemu_mutex_lock_ramlist(); 589 590 if (ram_list.version != last_version) { 591 reset_ram_globals(); 592 } 593 594 t0 = qemu_get_clock_ns(rt_clock); 595 i = 0; 596 while ((ret = qemu_file_rate_limit(f)) == 0) { 597 int bytes_sent; 598 599 bytes_sent = ram_save_block(f, false); 600 /* no more blocks to sent */ 601 if (bytes_sent == 0) { 602 break; 603 } 604 total_sent += bytes_sent; 605 acct_info.iterations++; 606 /* we want to check in the 1st loop, just in case it was the 1st time 607 and we had to sync the dirty bitmap. 608 qemu_get_clock_ns() is a bit expensive, so we only check each some 609 iterations 610 */ 611 if ((i & 63) == 0) { 612 uint64_t t1 = (qemu_get_clock_ns(rt_clock) - t0) / 1000000; 613 if (t1 > MAX_WAIT) { 614 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n", 615 t1, i); 616 break; 617 } 618 } 619 i++; 620 } 621 622 qemu_mutex_unlock_ramlist(); 623 624 if (ret < 0) { 625 bytes_transferred += total_sent; 626 return ret; 627 } 628 629 qemu_put_be64(f, RAM_SAVE_FLAG_EOS); 630 total_sent += 8; 631 bytes_transferred += total_sent; 632 633 return total_sent; 634 } 635 636 static int ram_save_complete(QEMUFile *f, void *opaque) 637 { 638 qemu_mutex_lock_ramlist(); 639 migration_bitmap_sync(); 640 641 /* try transferring iterative blocks of memory */ 642 643 /* flush all remaining blocks regardless of rate limiting */ 644 while (true) { 645 int bytes_sent; 646 647 bytes_sent = ram_save_block(f, true); 648 /* no more blocks to sent */ 649 if (bytes_sent == 0) { 650 break; 651 } 652 bytes_transferred += bytes_sent; 653 } 654 migration_end(); 655 656 qemu_mutex_unlock_ramlist(); 657 qemu_put_be64(f, RAM_SAVE_FLAG_EOS); 658 659 return 0; 660 } 661 662 static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size) 663 { 664 uint64_t remaining_size; 665 666 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE; 667 668 if (remaining_size < max_size) { 669 qemu_mutex_lock_iothread(); 670 migration_bitmap_sync(); 671 qemu_mutex_unlock_iothread(); 672 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE; 673 } 674 return remaining_size; 675 } 676 677 static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host) 678 { 679 int ret, rc = 0; 680 unsigned int xh_len; 681 int xh_flags; 682 683 if (!XBZRLE.decoded_buf) { 684 XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE); 685 } 686 687 /* extract RLE header */ 688 xh_flags = qemu_get_byte(f); 689 xh_len = qemu_get_be16(f); 690 691 if (xh_flags != ENCODING_FLAG_XBZRLE) { 692 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n"); 693 return -1; 694 } 695 696 if (xh_len > TARGET_PAGE_SIZE) { 697 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n"); 698 return -1; 699 } 700 /* load data and decode */ 701 qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len); 702 703 /* decode RLE */ 704 ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host, 705 TARGET_PAGE_SIZE); 706 if (ret == -1) { 707 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n"); 708 rc = -1; 709 } else if (ret > TARGET_PAGE_SIZE) { 710 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n", 711 ret, TARGET_PAGE_SIZE); 712 abort(); 713 } 714 715 return rc; 716 } 717 718 static inline void *host_from_stream_offset(QEMUFile *f, 719 ram_addr_t offset, 720 int flags) 721 { 722 static RAMBlock *block = NULL; 723 char id[256]; 724 uint8_t len; 725 726 if (flags & RAM_SAVE_FLAG_CONTINUE) { 727 if (!block) { 728 fprintf(stderr, "Ack, bad migration stream!\n"); 729 return NULL; 730 } 731 732 return memory_region_get_ram_ptr(block->mr) + offset; 733 } 734 735 len = qemu_get_byte(f); 736 qemu_get_buffer(f, (uint8_t *)id, len); 737 id[len] = 0; 738 739 QTAILQ_FOREACH(block, &ram_list.blocks, next) { 740 if (!strncmp(id, block->idstr, sizeof(id))) 741 return memory_region_get_ram_ptr(block->mr) + offset; 742 } 743 744 fprintf(stderr, "Can't find block %s!\n", id); 745 return NULL; 746 } 747 748 static int ram_load(QEMUFile *f, void *opaque, int version_id) 749 { 750 ram_addr_t addr; 751 int flags, ret = 0; 752 int error; 753 static uint64_t seq_iter; 754 755 seq_iter++; 756 757 if (version_id < 4 || version_id > 4) { 758 return -EINVAL; 759 } 760 761 do { 762 addr = qemu_get_be64(f); 763 764 flags = addr & ~TARGET_PAGE_MASK; 765 addr &= TARGET_PAGE_MASK; 766 767 if (flags & RAM_SAVE_FLAG_MEM_SIZE) { 768 if (version_id == 4) { 769 /* Synchronize RAM block list */ 770 char id[256]; 771 ram_addr_t length; 772 ram_addr_t total_ram_bytes = addr; 773 774 while (total_ram_bytes) { 775 RAMBlock *block; 776 uint8_t len; 777 778 len = qemu_get_byte(f); 779 qemu_get_buffer(f, (uint8_t *)id, len); 780 id[len] = 0; 781 length = qemu_get_be64(f); 782 783 QTAILQ_FOREACH(block, &ram_list.blocks, next) { 784 if (!strncmp(id, block->idstr, sizeof(id))) { 785 if (block->length != length) { 786 ret = -EINVAL; 787 goto done; 788 } 789 break; 790 } 791 } 792 793 if (!block) { 794 fprintf(stderr, "Unknown ramblock \"%s\", cannot " 795 "accept migration\n", id); 796 ret = -EINVAL; 797 goto done; 798 } 799 800 total_ram_bytes -= length; 801 } 802 } 803 } 804 805 if (flags & RAM_SAVE_FLAG_COMPRESS) { 806 void *host; 807 uint8_t ch; 808 809 host = host_from_stream_offset(f, addr, flags); 810 if (!host) { 811 return -EINVAL; 812 } 813 814 ch = qemu_get_byte(f); 815 memset(host, ch, TARGET_PAGE_SIZE); 816 #ifndef _WIN32 817 if (ch == 0 && 818 (!kvm_enabled() || kvm_has_sync_mmu()) && 819 getpagesize() <= TARGET_PAGE_SIZE) { 820 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED); 821 } 822 #endif 823 } else if (flags & RAM_SAVE_FLAG_PAGE) { 824 void *host; 825 826 host = host_from_stream_offset(f, addr, flags); 827 if (!host) { 828 return -EINVAL; 829 } 830 831 qemu_get_buffer(f, host, TARGET_PAGE_SIZE); 832 } else if (flags & RAM_SAVE_FLAG_XBZRLE) { 833 void *host = host_from_stream_offset(f, addr, flags); 834 if (!host) { 835 return -EINVAL; 836 } 837 838 if (load_xbzrle(f, addr, host) < 0) { 839 ret = -EINVAL; 840 goto done; 841 } 842 } 843 error = qemu_file_get_error(f); 844 if (error) { 845 ret = error; 846 goto done; 847 } 848 } while (!(flags & RAM_SAVE_FLAG_EOS)); 849 850 done: 851 DPRINTF("Completed load of VM with exit code %d seq iteration " 852 "%" PRIu64 "\n", ret, seq_iter); 853 return ret; 854 } 855 856 SaveVMHandlers savevm_ram_handlers = { 857 .save_live_setup = ram_save_setup, 858 .save_live_iterate = ram_save_iterate, 859 .save_live_complete = ram_save_complete, 860 .save_live_pending = ram_save_pending, 861 .load_state = ram_load, 862 .cancel = ram_migration_cancel, 863 }; 864 865 #ifdef HAS_AUDIO 866 struct soundhw { 867 const char *name; 868 const char *descr; 869 int enabled; 870 int isa; 871 union { 872 int (*init_isa) (ISABus *bus); 873 int (*init_pci) (PCIBus *bus); 874 } init; 875 }; 876 877 static struct soundhw soundhw[] = { 878 #ifdef HAS_AUDIO_CHOICE 879 #ifdef CONFIG_PCSPK 880 { 881 "pcspk", 882 "PC speaker", 883 0, 884 1, 885 { .init_isa = pcspk_audio_init } 886 }, 887 #endif 888 889 #ifdef CONFIG_SB16 890 { 891 "sb16", 892 "Creative Sound Blaster 16", 893 0, 894 1, 895 { .init_isa = SB16_init } 896 }, 897 #endif 898 899 #ifdef CONFIG_CS4231A 900 { 901 "cs4231a", 902 "CS4231A", 903 0, 904 1, 905 { .init_isa = cs4231a_init } 906 }, 907 #endif 908 909 #ifdef CONFIG_ADLIB 910 { 911 "adlib", 912 #ifdef HAS_YMF262 913 "Yamaha YMF262 (OPL3)", 914 #else 915 "Yamaha YM3812 (OPL2)", 916 #endif 917 0, 918 1, 919 { .init_isa = Adlib_init } 920 }, 921 #endif 922 923 #ifdef CONFIG_GUS 924 { 925 "gus", 926 "Gravis Ultrasound GF1", 927 0, 928 1, 929 { .init_isa = GUS_init } 930 }, 931 #endif 932 933 #ifdef CONFIG_AC97 934 { 935 "ac97", 936 "Intel 82801AA AC97 Audio", 937 0, 938 0, 939 { .init_pci = ac97_init } 940 }, 941 #endif 942 943 #ifdef CONFIG_ES1370 944 { 945 "es1370", 946 "ENSONIQ AudioPCI ES1370", 947 0, 948 0, 949 { .init_pci = es1370_init } 950 }, 951 #endif 952 953 #ifdef CONFIG_HDA 954 { 955 "hda", 956 "Intel HD Audio", 957 0, 958 0, 959 { .init_pci = intel_hda_and_codec_init } 960 }, 961 #endif 962 963 #endif /* HAS_AUDIO_CHOICE */ 964 965 { NULL, NULL, 0, 0, { NULL } } 966 }; 967 968 void select_soundhw(const char *optarg) 969 { 970 struct soundhw *c; 971 972 if (is_help_option(optarg)) { 973 show_valid_cards: 974 975 #ifdef HAS_AUDIO_CHOICE 976 printf("Valid sound card names (comma separated):\n"); 977 for (c = soundhw; c->name; ++c) { 978 printf ("%-11s %s\n", c->name, c->descr); 979 } 980 printf("\n-soundhw all will enable all of the above\n"); 981 #else 982 printf("Machine has no user-selectable audio hardware " 983 "(it may or may not have always-present audio hardware).\n"); 984 #endif 985 exit(!is_help_option(optarg)); 986 } 987 else { 988 size_t l; 989 const char *p; 990 char *e; 991 int bad_card = 0; 992 993 if (!strcmp(optarg, "all")) { 994 for (c = soundhw; c->name; ++c) { 995 c->enabled = 1; 996 } 997 return; 998 } 999 1000 p = optarg; 1001 while (*p) { 1002 e = strchr(p, ','); 1003 l = !e ? strlen(p) : (size_t) (e - p); 1004 1005 for (c = soundhw; c->name; ++c) { 1006 if (!strncmp(c->name, p, l) && !c->name[l]) { 1007 c->enabled = 1; 1008 break; 1009 } 1010 } 1011 1012 if (!c->name) { 1013 if (l > 80) { 1014 fprintf(stderr, 1015 "Unknown sound card name (too big to show)\n"); 1016 } 1017 else { 1018 fprintf(stderr, "Unknown sound card name `%.*s'\n", 1019 (int) l, p); 1020 } 1021 bad_card = 1; 1022 } 1023 p += l + (e != NULL); 1024 } 1025 1026 if (bad_card) { 1027 goto show_valid_cards; 1028 } 1029 } 1030 } 1031 1032 void audio_init(ISABus *isa_bus, PCIBus *pci_bus) 1033 { 1034 struct soundhw *c; 1035 1036 for (c = soundhw; c->name; ++c) { 1037 if (c->enabled) { 1038 if (c->isa) { 1039 if (isa_bus) { 1040 c->init.init_isa(isa_bus); 1041 } 1042 } else { 1043 if (pci_bus) { 1044 c->init.init_pci(pci_bus); 1045 } 1046 } 1047 } 1048 } 1049 } 1050 #else 1051 void select_soundhw(const char *optarg) 1052 { 1053 } 1054 void audio_init(ISABus *isa_bus, PCIBus *pci_bus) 1055 { 1056 } 1057 #endif 1058 1059 int qemu_uuid_parse(const char *str, uint8_t *uuid) 1060 { 1061 int ret; 1062 1063 if (strlen(str) != 36) { 1064 return -1; 1065 } 1066 1067 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3], 1068 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9], 1069 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], 1070 &uuid[15]); 1071 1072 if (ret != 16) { 1073 return -1; 1074 } 1075 #ifdef TARGET_I386 1076 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid); 1077 #endif 1078 return 0; 1079 } 1080 1081 void do_acpitable_option(const char *optarg) 1082 { 1083 #ifdef TARGET_I386 1084 if (acpi_table_add(optarg) < 0) { 1085 fprintf(stderr, "Wrong acpi table provided\n"); 1086 exit(1); 1087 } 1088 #endif 1089 } 1090 1091 void do_smbios_option(const char *optarg) 1092 { 1093 #ifdef TARGET_I386 1094 if (smbios_entry_add(optarg) < 0) { 1095 fprintf(stderr, "Wrong smbios provided\n"); 1096 exit(1); 1097 } 1098 #endif 1099 } 1100 1101 void cpudef_init(void) 1102 { 1103 #if defined(cpudef_setup) 1104 cpudef_setup(); /* parse cpu definitions in target config file */ 1105 #endif 1106 } 1107 1108 int audio_available(void) 1109 { 1110 #ifdef HAS_AUDIO 1111 return 1; 1112 #else 1113 return 0; 1114 #endif 1115 } 1116 1117 int tcg_available(void) 1118 { 1119 return 1; 1120 } 1121 1122 int kvm_available(void) 1123 { 1124 #ifdef CONFIG_KVM 1125 return 1; 1126 #else 1127 return 0; 1128 #endif 1129 } 1130 1131 int xen_available(void) 1132 { 1133 #ifdef CONFIG_XEN 1134 return 1; 1135 #else 1136 return 0; 1137 #endif 1138 } 1139 1140 1141 TargetInfo *qmp_query_target(Error **errp) 1142 { 1143 TargetInfo *info = g_malloc0(sizeof(*info)); 1144 1145 info->arch = TARGET_TYPE; 1146 1147 return info; 1148 } 1149