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/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 static bool ram_bulk_stage;
 323
 324 static inline
 325 ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
 326                                                  ram_addr_t start)
 327 {
 328     unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS;
 329     unsigned long nr = base + (start >> TARGET_PAGE_BITS);
 330     unsigned long size = base + (int128_get64(mr->size) >> TARGET_PAGE_BITS);
 331
 332     unsigned long next = find_next_bit(migration_bitmap, size, nr);
 333
 334     if (next < size) {
 335         clear_bit(next, migration_bitmap);
 336         migration_dirty_pages--;
 337     }
 338     return (next - base) << TARGET_PAGE_BITS;
 339 }
 340
 341 static inline bool migration_bitmap_set_dirty(MemoryRegion *mr,
 342                                               ram_addr_t offset)
 343 {
 344     bool ret;
 345     int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS;
 346
 347     ret = test_and_set_bit(nr, migration_bitmap);
 348
 349     if (!ret) {
 350         migration_dirty_pages++;
 351     }
 352     return ret;
 353 }
 354
 355 /* Needs iothread lock! */
 356
 357 static void migration_bitmap_sync(void)
 358 {
 359     RAMBlock *block;
 360     ram_addr_t addr;
 361     uint64_t num_dirty_pages_init = migration_dirty_pages;
 362     MigrationState *s = migrate_get_current();
 363     static int64_t start_time;
 364     static int64_t num_dirty_pages_period;
 365     int64_t end_time;
 366
 367     if (!start_time) {
 368         start_time = qemu_get_clock_ms(rt_clock);
 369     }
 370
 371     trace_migration_bitmap_sync_start();
 372     memory_global_sync_dirty_bitmap(get_system_memory());
 373
 374     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
 375         for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) {
 376             if (memory_region_test_and_clear_dirty(block->mr,
 377                                                    addr, TARGET_PAGE_SIZE,
 378                                                    DIRTY_MEMORY_MIGRATION)) {
 379                 migration_bitmap_set_dirty(block->mr, addr);
 380             }
 381         }
 382     }
 383     trace_migration_bitmap_sync_end(migration_dirty_pages
 384                                     - num_dirty_pages_init);
 385     num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
 386     end_time = qemu_get_clock_ms(rt_clock);
 387
 388     /* more than 1 second = 1000 millisecons */
 389     if (end_time > start_time + 1000) {
 390         s->dirty_pages_rate = num_dirty_pages_period * 1000
 391             / (end_time - start_time);
 392         s->dirty_bytes_rate = s->dirty_pages_rate * TARGET_PAGE_SIZE;
 393         start_time = end_time;
 394         num_dirty_pages_period = 0;
 395     }
 396 }
 397
 398 /*
 399  * ram_save_block: Writes a page of memory to the stream f
 400  *
 401  * Returns:  The number of bytes written.
 402  *           0 means no dirty pages
 403  */
 404
 405 static int ram_save_block(QEMUFile *f, bool last_stage)
 406 {
 407     RAMBlock *block = last_seen_block;
 408     ram_addr_t offset = last_offset;
 409     bool complete_round = false;
 410     int bytes_sent = 0;
 411     MemoryRegion *mr;
 412     ram_addr_t current_addr;
 413
 414     if (!block)
 415         block = QTAILQ_FIRST(&ram_list.blocks);
 416
 417     while (true) {
 418         mr = block->mr;
 419         offset = migration_bitmap_find_and_reset_dirty(mr, offset);
 420         if (complete_round && block == last_seen_block &&
 421             offset >= last_offset) {
 422             break;
 423         }
 424         if (offset >= block->length) {
 425             offset = 0;
 426             block = QTAILQ_NEXT(block, next);
 427             if (!block) {
 428                 block = QTAILQ_FIRST(&ram_list.blocks);
 429                 complete_round = true;
 430                 ram_bulk_stage = false;
 431             }
 432         } else {
 433             uint8_t *p;
 434             int cont = (block == last_sent_block) ?
 435                 RAM_SAVE_FLAG_CONTINUE : 0;
 436
 437             p = memory_region_get_ram_ptr(mr) + offset;
 438
 439             /* In doubt sent page as normal */
 440             bytes_sent = -1;
 441             if (is_zero_page(p)) {
 442                 acct_info.dup_pages++;
 443                 bytes_sent = save_block_hdr(f, block, offset, cont,
 444                                             RAM_SAVE_FLAG_COMPRESS);
 445                 qemu_put_byte(f, 0);
 446                 bytes_sent++;
 447             } else if (migrate_use_xbzrle()) {
 448                 current_addr = block->offset + offset;
 449                 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
 450                                               offset, cont, last_stage);
 451                 if (!last_stage) {
 452                     p = get_cached_data(XBZRLE.cache, current_addr);
 453                 }
 454             }
 455
 456             /* XBZRLE overflow or normal page */
 457             if (bytes_sent == -1) {
 458                 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
 459                 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
 460                 bytes_sent += TARGET_PAGE_SIZE;
 461                 acct_info.norm_pages++;
 462             }
 463
 464             /* if page is unmodified, continue to the next */
 465             if (bytes_sent > 0) {
 466                 last_sent_block = block;
 467                 break;
 468             }
 469         }
 470     }
 471     last_seen_block = block;
 472     last_offset = offset;
 473
 474     return bytes_sent;
 475 }
 476
 477 static uint64_t bytes_transferred;
 478
 479 static ram_addr_t ram_save_remaining(void)
 480 {
 481     return migration_dirty_pages;
 482 }
 483
 484 uint64_t ram_bytes_remaining(void)
 485 {
 486     return ram_save_remaining() * TARGET_PAGE_SIZE;
 487 }
 488
 489 uint64_t ram_bytes_transferred(void)
 490 {
 491     return bytes_transferred;
 492 }
 493
 494 uint64_t ram_bytes_total(void)
 495 {
 496     RAMBlock *block;
 497     uint64_t total = 0;
 498
 499     QTAILQ_FOREACH(block, &ram_list.blocks, next)
 500         total += block->length;
 501
 502     return total;
 503 }
 504
 505 static void migration_end(void)
 506 {
 507     if (migration_bitmap) {
 508         memory_global_dirty_log_stop();
 509         g_free(migration_bitmap);
 510         migration_bitmap = NULL;
 511     }
 512
 513     if (XBZRLE.cache) {
 514         cache_fini(XBZRLE.cache);
 515         g_free(XBZRLE.cache);
 516         g_free(XBZRLE.encoded_buf);
 517         g_free(XBZRLE.current_buf);
 518         g_free(XBZRLE.decoded_buf);
 519         XBZRLE.cache = NULL;
 520     }
 521 }
 522
 523 static void ram_migration_cancel(void *opaque)
 524 {
 525     migration_end();
 526 }
 527
 528 static void reset_ram_globals(void)
 529 {
 530     last_seen_block = NULL;
 531     last_sent_block = NULL;
 532     last_offset = 0;
 533     last_version = ram_list.version;
 534     ram_bulk_stage = true;
 535 }
 536
 537 #define MAX_WAIT 50 /* ms, half buffered_file limit */
 538
 539 static int ram_save_setup(QEMUFile *f, void *opaque)
 540 {
 541     RAMBlock *block;
 542     int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
 543
 544     migration_bitmap = bitmap_new(ram_pages);
 545     bitmap_set(migration_bitmap, 0, ram_pages);
 546     migration_dirty_pages = ram_pages;
 547
 548     if (migrate_use_xbzrle()) {
 549         XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
 550                                   TARGET_PAGE_SIZE,
 551                                   TARGET_PAGE_SIZE);
 552         if (!XBZRLE.cache) {
 553             DPRINTF("Error creating cache\n");
 554             return -1;
 555         }
 556         XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE);
 557         XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE);
 558         acct_clear();
 559     }
 560
 561     qemu_mutex_lock_iothread();
 562     qemu_mutex_lock_ramlist();
 563     bytes_transferred = 0;
 564     reset_ram_globals();
 565
 566     memory_global_dirty_log_start();
 567     migration_bitmap_sync();
 568     qemu_mutex_unlock_iothread();
 569
 570     qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
 571
 572     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
 573         qemu_put_byte(f, strlen(block->idstr));
 574         qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
 575         qemu_put_be64(f, block->length);
 576     }
 577
 578     qemu_mutex_unlock_ramlist();
 579     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 580
 581     return 0;
 582 }
 583
 584 static int ram_save_iterate(QEMUFile *f, void *opaque)
 585 {
 586     int ret;
 587     int i;
 588     int64_t t0;
 589     int total_sent = 0;
 590
 591     qemu_mutex_lock_ramlist();
 592
 593     if (ram_list.version != last_version) {
 594         reset_ram_globals();
 595     }
 596
 597     t0 = qemu_get_clock_ns(rt_clock);
 598     i = 0;
 599     while ((ret = qemu_file_rate_limit(f)) == 0) {
 600         int bytes_sent;
 601
 602         bytes_sent = ram_save_block(f, false);
 603         /* no more blocks to sent */
 604         if (bytes_sent == 0) {
 605             break;
 606         }
 607         total_sent += bytes_sent;
 608         acct_info.iterations++;
 609         /* we want to check in the 1st loop, just in case it was the 1st time
 610            and we had to sync the dirty bitmap.
 611            qemu_get_clock_ns() is a bit expensive, so we only check each some
 612            iterations
 613         */
 614         if ((i & 63) == 0) {
 615             uint64_t t1 = (qemu_get_clock_ns(rt_clock) - t0) / 1000000;
 616             if (t1 > MAX_WAIT) {
 617                 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
 618                         t1, i);
 619                 break;
 620             }
 621         }
 622         i++;
 623     }
 624
 625     qemu_mutex_unlock_ramlist();
 626
 627     if (ret < 0) {
 628         bytes_transferred += total_sent;
 629         return ret;
 630     }
 631
 632     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 633     total_sent += 8;
 634     bytes_transferred += total_sent;
 635
 636     return total_sent;
 637 }
 638
 639 static int ram_save_complete(QEMUFile *f, void *opaque)
 640 {
 641     qemu_mutex_lock_ramlist();
 642     migration_bitmap_sync();
 643
 644     /* try transferring iterative blocks of memory */
 645
 646     /* flush all remaining blocks regardless of rate limiting */
 647     while (true) {
 648         int bytes_sent;
 649
 650         bytes_sent = ram_save_block(f, true);
 651         /* no more blocks to sent */
 652         if (bytes_sent == 0) {
 653             break;
 654         }
 655         bytes_transferred += bytes_sent;
 656     }
 657     migration_end();
 658
 659     qemu_mutex_unlock_ramlist();
 660     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 661
 662     return 0;
 663 }
 664
 665 static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size)
 666 {
 667     uint64_t remaining_size;
 668
 669     remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
 670
 671     if (remaining_size < max_size) {
 672         qemu_mutex_lock_iothread();
 673         migration_bitmap_sync();
 674         qemu_mutex_unlock_iothread();
 675         remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
 676     }
 677     return remaining_size;
 678 }
 679
 680 static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
 681 {
 682     int ret, rc = 0;
 683     unsigned int xh_len;
 684     int xh_flags;
 685
 686     if (!XBZRLE.decoded_buf) {
 687         XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE);
 688     }
 689
 690     /* extract RLE header */
 691     xh_flags = qemu_get_byte(f);
 692     xh_len = qemu_get_be16(f);
 693
 694     if (xh_flags != ENCODING_FLAG_XBZRLE) {
 695         fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
 696         return -1;
 697     }
 698
 699     if (xh_len > TARGET_PAGE_SIZE) {
 700         fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
 701         return -1;
 702     }
 703     /* load data and decode */
 704     qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len);
 705
 706     /* decode RLE */
 707     ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host,
 708                                TARGET_PAGE_SIZE);
 709     if (ret == -1) {
 710         fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
 711         rc = -1;
 712     } else  if (ret > TARGET_PAGE_SIZE) {
 713         fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
 714                 ret, TARGET_PAGE_SIZE);
 715         abort();
 716     }
 717
 718     return rc;
 719 }
 720
 721 static inline void *host_from_stream_offset(QEMUFile *f,
 722                                             ram_addr_t offset,
 723                                             int flags)
 724 {
 725     static RAMBlock *block = NULL;
 726     char id[256];
 727     uint8_t len;
 728
 729     if (flags & RAM_SAVE_FLAG_CONTINUE) {
 730         if (!block) {
 731             fprintf(stderr, "Ack, bad migration stream!\n");
 732             return NULL;
 733         }
 734
 735         return memory_region_get_ram_ptr(block->mr) + offset;
 736     }
 737
 738     len = qemu_get_byte(f);
 739     qemu_get_buffer(f, (uint8_t *)id, len);
 740     id[len] = 0;
 741
 742     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
 743         if (!strncmp(id, block->idstr, sizeof(id)))
 744             return memory_region_get_ram_ptr(block->mr) + offset;
 745     }
 746
 747     fprintf(stderr, "Can't find block %s!\n", id);
 748     return NULL;
 749 }
 750
 751 static int ram_load(QEMUFile *f, void *opaque, int version_id)
 752 {
 753     ram_addr_t addr;
 754     int flags, ret = 0;
 755     int error;
 756     static uint64_t seq_iter;
 757
 758     seq_iter++;
 759
 760     if (version_id < 4 || version_id > 4) {
 761         return -EINVAL;
 762     }
 763
 764     do {
 765         addr = qemu_get_be64(f);
 766
 767         flags = addr & ~TARGET_PAGE_MASK;
 768         addr &= TARGET_PAGE_MASK;
 769
 770         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
 771             if (version_id == 4) {
 772                 /* Synchronize RAM block list */
 773                 char id[256];
 774                 ram_addr_t length;
 775                 ram_addr_t total_ram_bytes = addr;
 776
 777                 while (total_ram_bytes) {
 778                     RAMBlock *block;
 779                     uint8_t len;
 780
 781                     len = qemu_get_byte(f);
 782                     qemu_get_buffer(f, (uint8_t *)id, len);
 783                     id[len] = 0;
 784                     length = qemu_get_be64(f);
 785
 786                     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
 787                         if (!strncmp(id, block->idstr, sizeof(id))) {
 788                             if (block->length != length) {
 789                                 ret =  -EINVAL;
 790                                 goto done;
 791                             }
 792                             break;
 793                         }
 794                     }
 795
 796                     if (!block) {
 797                         fprintf(stderr, "Unknown ramblock \"%s\", cannot "
 798                                 "accept migration\n", id);
 799                         ret = -EINVAL;
 800                         goto done;
 801                     }
 802
 803                     total_ram_bytes -= length;
 804                 }
 805             }
 806         }
 807
 808         if (flags & RAM_SAVE_FLAG_COMPRESS) {
 809             void *host;
 810             uint8_t ch;
 811
 812             host = host_from_stream_offset(f, addr, flags);
 813             if (!host) {
 814                 return -EINVAL;
 815             }
 816
 817             ch = qemu_get_byte(f);
 818             memset(host, ch, TARGET_PAGE_SIZE);
 819 #ifndef _WIN32
 820             if (ch == 0 &&
 821                 (!kvm_enabled() || kvm_has_sync_mmu()) &&
 822                 getpagesize() <= TARGET_PAGE_SIZE) {
 823                 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED);
 824             }
 825 #endif
 826         } else if (flags & RAM_SAVE_FLAG_PAGE) {
 827             void *host;
 828
 829             host = host_from_stream_offset(f, addr, flags);
 830             if (!host) {
 831                 return -EINVAL;
 832             }
 833
 834             qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
 835         } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
 836             void *host = host_from_stream_offset(f, addr, flags);
 837             if (!host) {
 838                 return -EINVAL;
 839             }
 840
 841             if (load_xbzrle(f, addr, host) < 0) {
 842                 ret = -EINVAL;
 843                 goto done;
 844             }
 845         }
 846         error = qemu_file_get_error(f);
 847         if (error) {
 848             ret = error;
 849             goto done;
 850         }
 851     } while (!(flags & RAM_SAVE_FLAG_EOS));
 852
 853 done:
 854     DPRINTF("Completed load of VM with exit code %d seq iteration "
 855             "%" PRIu64 "\n", ret, seq_iter);
 856     return ret;
 857 }
 858
 859 SaveVMHandlers savevm_ram_handlers = {
 860     .save_live_setup = ram_save_setup,
 861     .save_live_iterate = ram_save_iterate,
 862     .save_live_complete = ram_save_complete,
 863     .save_live_pending = ram_save_pending,
 864     .load_state = ram_load,
 865     .cancel = ram_migration_cancel,
 866 };
 867
 868 #ifdef HAS_AUDIO
 869 struct soundhw {
 870     const char *name;
 871     const char *descr;
 872     int enabled;
 873     int isa;
 874     union {
 875         int (*init_isa) (ISABus *bus);
 876         int (*init_pci) (PCIBus *bus);
 877     } init;
 878 };
 879
 880 static struct soundhw soundhw[] = {
 881 #ifdef HAS_AUDIO_CHOICE
 882 #ifdef CONFIG_PCSPK
 883     {
 884         "pcspk",
 885         "PC speaker",
 886         0,
 887         1,
 888         { .init_isa = pcspk_audio_init }
 889     },
 890 #endif
 891
 892 #ifdef CONFIG_SB16
 893     {
 894         "sb16",
 895         "Creative Sound Blaster 16",
 896         0,
 897         1,
 898         { .init_isa = SB16_init }
 899     },
 900 #endif
 901
 902 #ifdef CONFIG_CS4231A
 903     {
 904         "cs4231a",
 905         "CS4231A",
 906         0,
 907         1,
 908         { .init_isa = cs4231a_init }
 909     },
 910 #endif
 911
 912 #ifdef CONFIG_ADLIB
 913     {
 914         "adlib",
 915 #ifdef HAS_YMF262
 916         "Yamaha YMF262 (OPL3)",
 917 #else
 918         "Yamaha YM3812 (OPL2)",
 919 #endif
 920         0,
 921         1,
 922         { .init_isa = Adlib_init }
 923     },
 924 #endif
 925
 926 #ifdef CONFIG_GUS
 927     {
 928         "gus",
 929         "Gravis Ultrasound GF1",
 930         0,
 931         1,
 932         { .init_isa = GUS_init }
 933     },
 934 #endif
 935
 936 #ifdef CONFIG_AC97
 937     {
 938         "ac97",
 939         "Intel 82801AA AC97 Audio",
 940         0,
 941         0,
 942         { .init_pci = ac97_init }
 943     },
 944 #endif
 945
 946 #ifdef CONFIG_ES1370
 947     {
 948         "es1370",
 949         "ENSONIQ AudioPCI ES1370",
 950         0,
 951         0,
 952         { .init_pci = es1370_init }
 953     },
 954 #endif
 955
 956 #ifdef CONFIG_HDA
 957     {
 958         "hda",
 959         "Intel HD Audio",
 960         0,
 961         0,
 962         { .init_pci = intel_hda_and_codec_init }
 963     },
 964 #endif
 965
 966 #endif /* HAS_AUDIO_CHOICE */
 967
 968     { NULL, NULL, 0, 0, { NULL } }
 969 };
 970
 971 void select_soundhw(const char *optarg)
 972 {
 973     struct soundhw *c;
 974
 975     if (is_help_option(optarg)) {
 976     show_valid_cards:
 977
 978 #ifdef HAS_AUDIO_CHOICE
 979         printf("Valid sound card names (comma separated):\n");
 980         for (c = soundhw; c->name; ++c) {
 981             printf ("%-11s %s\n", c->name, c->descr);
 982         }
 983         printf("\n-soundhw all will enable all of the above\n");
 984 #else
 985         printf("Machine has no user-selectable audio hardware "
 986                "(it may or may not have always-present audio hardware).\n");
 987 #endif
 988         exit(!is_help_option(optarg));
 989     }
 990     else {
 991         size_t l;
 992         const char *p;
 993         char *e;
 994         int bad_card = 0;
 995
 996         if (!strcmp(optarg, "all")) {
 997             for (c = soundhw; c->name; ++c) {
 998                 c->enabled = 1;
 999             }
1000             return;
1001         }
1002
1003         p = optarg;
1004         while (*p) {
1005             e = strchr(p, ',');
1006             l = !e ? strlen(p) : (size_t) (e - p);
1007
1008             for (c = soundhw; c->name; ++c) {
1009                 if (!strncmp(c->name, p, l) && !c->name[l]) {
1010                     c->enabled = 1;
1011                     break;
1012                 }
1013             }
1014
1015             if (!c->name) {
1016                 if (l > 80) {
1017                     fprintf(stderr,
1018                             "Unknown sound card name (too big to show)\n");
1019                 }
1020                 else {
1021                     fprintf(stderr, "Unknown sound card name `%.*s'\n",
1022                             (int) l, p);
1023                 }
1024                 bad_card = 1;
1025             }
1026             p += l + (e != NULL);
1027         }
1028
1029         if (bad_card) {
1030             goto show_valid_cards;
1031         }
1032     }
1033 }
1034
1035 void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
1036 {
1037     struct soundhw *c;
1038
1039     for (c = soundhw; c->name; ++c) {
1040         if (c->enabled) {
1041             if (c->isa) {
1042                 if (isa_bus) {
1043                     c->init.init_isa(isa_bus);
1044                 }
1045             } else {
1046                 if (pci_bus) {
1047                     c->init.init_pci(pci_bus);
1048                 }
1049             }
1050         }
1051     }
1052 }
1053 #else
1054 void select_soundhw(const char *optarg)
1055 {
1056 }
1057 void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
1058 {
1059 }
1060 #endif
1061
1062 int qemu_uuid_parse(const char *str, uint8_t *uuid)
1063 {
1064     int ret;
1065
1066     if (strlen(str) != 36) {
1067         return -1;
1068     }
1069
1070     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1071                  &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1072                  &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1073                  &uuid[15]);
1074
1075     if (ret != 16) {
1076         return -1;
1077     }
1078 #ifdef TARGET_I386
1079     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
1080 #endif
1081     return 0;
1082 }
1083
1084 void do_acpitable_option(const char *optarg)
1085 {
1086 #ifdef TARGET_I386
1087     if (acpi_table_add(optarg) < 0) {
1088         fprintf(stderr, "Wrong acpi table provided\n");
1089         exit(1);
1090     }
1091 #endif
1092 }
1093
1094 void do_smbios_option(const char *optarg)
1095 {
1096 #ifdef TARGET_I386
1097     if (smbios_entry_add(optarg) < 0) {
1098         fprintf(stderr, "Wrong smbios provided\n");
1099         exit(1);
1100     }
1101 #endif
1102 }
1103
1104 void cpudef_init(void)
1105 {
1106 #if defined(cpudef_setup)
1107     cpudef_setup(); /* parse cpu definitions in target config file */
1108 #endif
1109 }
1110
1111 int audio_available(void)
1112 {
1113 #ifdef HAS_AUDIO
1114     return 1;
1115 #else
1116     return 0;
1117 #endif
1118 }
1119
1120 int tcg_available(void)
1121 {
1122     return 1;
1123 }
1124
1125 int kvm_available(void)
1126 {
1127 #ifdef CONFIG_KVM
1128     return 1;
1129 #else
1130     return 0;
1131 #endif
1132 }
1133
1134 int xen_available(void)
1135 {
1136 #ifdef CONFIG_XEN
1137     return 1;
1138 #else
1139     return 0;
1140 #endif
1141 }
1142
1143
1144 TargetInfo *qmp_query_target(Error **errp)
1145 {
1146     TargetInfo *info = g_malloc0(sizeof(*info));
1147
1148     info->arch = TARGET_TYPE;
1149
1150     return info;
1151 }