arch_init.c

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