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 #ifndef _WIN32 27 #include <sys/types.h> 28 #include <sys/mman.h> 29 #endif 30 #include "config.h" 31 #include "monitor.h" 32 #include "sysemu.h" 33 #include "arch_init.h" 34 #include "audio/audio.h" 35 #include "hw/pc.h" 36 #include "hw/pci.h" 37 #include "hw/audiodev.h" 38 #include "kvm.h" 39 #include "migration.h" 40 #include "net.h" 41 #include "gdbstub.h" 42 #include "hw/smbios.h" 43 44 #ifdef TARGET_SPARC 45 int graphic_width = 1024; 46 int graphic_height = 768; 47 int graphic_depth = 8; 48 #else 49 int graphic_width = 800; 50 int graphic_height = 600; 51 int graphic_depth = 15; 52 #endif 53 54 const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf"; 55 56 #if defined(TARGET_ALPHA) 57 #define QEMU_ARCH QEMU_ARCH_ALPHA 58 #elif defined(TARGET_ARM) 59 #define QEMU_ARCH QEMU_ARCH_ARM 60 #elif defined(TARGET_CRIS) 61 #define QEMU_ARCH QEMU_ARCH_CRIS 62 #elif defined(TARGET_I386) 63 #define QEMU_ARCH QEMU_ARCH_I386 64 #elif defined(TARGET_M68K) 65 #define QEMU_ARCH QEMU_ARCH_M68K 66 #elif defined(TARGET_MICROBLAZE) 67 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE 68 #elif defined(TARGET_MIPS) 69 #define QEMU_ARCH QEMU_ARCH_MIPS 70 #elif defined(TARGET_PPC) 71 #define QEMU_ARCH QEMU_ARCH_PPC 72 #elif defined(TARGET_S390X) 73 #define QEMU_ARCH QEMU_ARCH_S390X 74 #elif defined(TARGET_SH4) 75 #define QEMU_ARCH QEMU_ARCH_SH4 76 #elif defined(TARGET_SPARC) 77 #define QEMU_ARCH QEMU_ARCH_SPARC 78 #endif 79 80 const uint32_t arch_type = QEMU_ARCH; 81 82 /***********************************************************/ 83 /* ram save/restore */ 84 85 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */ 86 #define RAM_SAVE_FLAG_COMPRESS 0x02 87 #define RAM_SAVE_FLAG_MEM_SIZE 0x04 88 #define RAM_SAVE_FLAG_PAGE 0x08 89 #define RAM_SAVE_FLAG_EOS 0x10 90 #define RAM_SAVE_FLAG_CONTINUE 0x20 91 92 static int is_dup_page(uint8_t *page, uint8_t ch) 93 { 94 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch; 95 uint32_t *array = (uint32_t *)page; 96 int i; 97 98 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) { 99 if (array[i] != val) { 100 return 0; 101 } 102 } 103 104 return 1; 105 } 106 107 static RAMBlock *last_block; 108 static ram_addr_t last_offset; 109 110 static int ram_save_block(QEMUFile *f) 111 { 112 RAMBlock *block = last_block; 113 ram_addr_t offset = last_offset; 114 ram_addr_t current_addr; 115 int bytes_sent = 0; 116 117 if (!block) 118 block = QLIST_FIRST(&ram_list.blocks); 119 120 current_addr = block->offset + offset; 121 122 do { 123 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) { 124 uint8_t *p; 125 int cont = (block == last_block) ? RAM_SAVE_FLAG_CONTINUE : 0; 126 127 cpu_physical_memory_reset_dirty(current_addr, 128 current_addr + TARGET_PAGE_SIZE, 129 MIGRATION_DIRTY_FLAG); 130 131 p = block->host + offset; 132 133 if (is_dup_page(p, *p)) { 134 qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_COMPRESS); 135 if (!cont) { 136 qemu_put_byte(f, strlen(block->idstr)); 137 qemu_put_buffer(f, (uint8_t *)block->idstr, 138 strlen(block->idstr)); 139 } 140 qemu_put_byte(f, *p); 141 bytes_sent = 1; 142 } else { 143 qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_PAGE); 144 if (!cont) { 145 qemu_put_byte(f, strlen(block->idstr)); 146 qemu_put_buffer(f, (uint8_t *)block->idstr, 147 strlen(block->idstr)); 148 } 149 qemu_put_buffer(f, p, TARGET_PAGE_SIZE); 150 bytes_sent = TARGET_PAGE_SIZE; 151 } 152 153 break; 154 } 155 156 offset += TARGET_PAGE_SIZE; 157 if (offset >= block->length) { 158 offset = 0; 159 block = QLIST_NEXT(block, next); 160 if (!block) 161 block = QLIST_FIRST(&ram_list.blocks); 162 } 163 164 current_addr = block->offset + offset; 165 166 } while (current_addr != last_block->offset + last_offset); 167 168 last_block = block; 169 last_offset = offset; 170 171 return bytes_sent; 172 } 173 174 static uint64_t bytes_transferred; 175 176 static ram_addr_t ram_save_remaining(void) 177 { 178 RAMBlock *block; 179 ram_addr_t count = 0; 180 181 QLIST_FOREACH(block, &ram_list.blocks, next) { 182 ram_addr_t addr; 183 for (addr = block->offset; addr < block->offset + block->length; 184 addr += TARGET_PAGE_SIZE) { 185 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) { 186 count++; 187 } 188 } 189 } 190 191 return count; 192 } 193 194 uint64_t ram_bytes_remaining(void) 195 { 196 return ram_save_remaining() * TARGET_PAGE_SIZE; 197 } 198 199 uint64_t ram_bytes_transferred(void) 200 { 201 return bytes_transferred; 202 } 203 204 uint64_t ram_bytes_total(void) 205 { 206 RAMBlock *block; 207 uint64_t total = 0; 208 209 QLIST_FOREACH(block, &ram_list.blocks, next) 210 total += block->length; 211 212 return total; 213 } 214 215 int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque) 216 { 217 ram_addr_t addr; 218 uint64_t bytes_transferred_last; 219 double bwidth = 0; 220 uint64_t expected_time = 0; 221 222 if (stage < 0) { 223 cpu_physical_memory_set_dirty_tracking(0); 224 return 0; 225 } 226 227 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) { 228 qemu_file_set_error(f); 229 return 0; 230 } 231 232 if (stage == 1) { 233 RAMBlock *block; 234 bytes_transferred = 0; 235 last_block = NULL; 236 last_offset = 0; 237 238 /* Make sure all dirty bits are set */ 239 QLIST_FOREACH(block, &ram_list.blocks, next) { 240 for (addr = block->offset; addr < block->offset + block->length; 241 addr += TARGET_PAGE_SIZE) { 242 if (!cpu_physical_memory_get_dirty(addr, 243 MIGRATION_DIRTY_FLAG)) { 244 cpu_physical_memory_set_dirty(addr); 245 } 246 } 247 } 248 249 /* Enable dirty memory tracking */ 250 cpu_physical_memory_set_dirty_tracking(1); 251 252 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE); 253 254 QLIST_FOREACH(block, &ram_list.blocks, next) { 255 qemu_put_byte(f, strlen(block->idstr)); 256 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr)); 257 qemu_put_be64(f, block->length); 258 } 259 } 260 261 bytes_transferred_last = bytes_transferred; 262 bwidth = qemu_get_clock_ns(rt_clock); 263 264 while (!qemu_file_rate_limit(f)) { 265 int bytes_sent; 266 267 bytes_sent = ram_save_block(f); 268 bytes_transferred += bytes_sent; 269 if (bytes_sent == 0) { /* no more blocks */ 270 break; 271 } 272 } 273 274 bwidth = qemu_get_clock_ns(rt_clock) - bwidth; 275 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth; 276 277 /* if we haven't transferred anything this round, force expected_time to a 278 * a very high value, but without crashing */ 279 if (bwidth == 0) { 280 bwidth = 0.000001; 281 } 282 283 /* try transferring iterative blocks of memory */ 284 if (stage == 3) { 285 int bytes_sent; 286 287 /* flush all remaining blocks regardless of rate limiting */ 288 while ((bytes_sent = ram_save_block(f)) != 0) { 289 bytes_transferred += bytes_sent; 290 } 291 cpu_physical_memory_set_dirty_tracking(0); 292 } 293 294 qemu_put_be64(f, RAM_SAVE_FLAG_EOS); 295 296 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth; 297 298 return (stage == 2) && (expected_time <= migrate_max_downtime()); 299 } 300 301 static inline void *host_from_stream_offset(QEMUFile *f, 302 ram_addr_t offset, 303 int flags) 304 { 305 static RAMBlock *block = NULL; 306 char id[256]; 307 uint8_t len; 308 309 if (flags & RAM_SAVE_FLAG_CONTINUE) { 310 if (!block) { 311 fprintf(stderr, "Ack, bad migration stream!\n"); 312 return NULL; 313 } 314 315 return block->host + offset; 316 } 317 318 len = qemu_get_byte(f); 319 qemu_get_buffer(f, (uint8_t *)id, len); 320 id[len] = 0; 321 322 QLIST_FOREACH(block, &ram_list.blocks, next) { 323 if (!strncmp(id, block->idstr, sizeof(id))) 324 return block->host + offset; 325 } 326 327 fprintf(stderr, "Can't find block %s!\n", id); 328 return NULL; 329 } 330 331 int ram_load(QEMUFile *f, void *opaque, int version_id) 332 { 333 ram_addr_t addr; 334 int flags; 335 336 if (version_id < 3 || version_id > 4) { 337 return -EINVAL; 338 } 339 340 do { 341 addr = qemu_get_be64(f); 342 343 flags = addr & ~TARGET_PAGE_MASK; 344 addr &= TARGET_PAGE_MASK; 345 346 if (flags & RAM_SAVE_FLAG_MEM_SIZE) { 347 if (version_id == 3) { 348 if (addr != ram_bytes_total()) { 349 return -EINVAL; 350 } 351 } else { 352 /* Synchronize RAM block list */ 353 char id[256]; 354 ram_addr_t length; 355 ram_addr_t total_ram_bytes = addr; 356 357 while (total_ram_bytes) { 358 RAMBlock *block; 359 uint8_t len; 360 361 len = qemu_get_byte(f); 362 qemu_get_buffer(f, (uint8_t *)id, len); 363 id[len] = 0; 364 length = qemu_get_be64(f); 365 366 QLIST_FOREACH(block, &ram_list.blocks, next) { 367 if (!strncmp(id, block->idstr, sizeof(id))) { 368 if (block->length != length) 369 return -EINVAL; 370 break; 371 } 372 } 373 374 if (!block) { 375 fprintf(stderr, "Unknown ramblock \"%s\", cannot " 376 "accept migration\n", id); 377 return -EINVAL; 378 } 379 380 total_ram_bytes -= length; 381 } 382 } 383 } 384 385 if (flags & RAM_SAVE_FLAG_COMPRESS) { 386 void *host; 387 uint8_t ch; 388 389 if (version_id == 3) 390 host = qemu_get_ram_ptr(addr); 391 else 392 host = host_from_stream_offset(f, addr, flags); 393 394 ch = qemu_get_byte(f); 395 memset(host, ch, TARGET_PAGE_SIZE); 396 #ifndef _WIN32 397 if (ch == 0 && 398 (!kvm_enabled() || kvm_has_sync_mmu())) { 399 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED); 400 } 401 #endif 402 } else if (flags & RAM_SAVE_FLAG_PAGE) { 403 void *host; 404 405 if (version_id == 3) 406 host = qemu_get_ram_ptr(addr); 407 else 408 host = host_from_stream_offset(f, addr, flags); 409 410 qemu_get_buffer(f, host, TARGET_PAGE_SIZE); 411 } 412 if (qemu_file_has_error(f)) { 413 return -EIO; 414 } 415 } while (!(flags & RAM_SAVE_FLAG_EOS)); 416 417 return 0; 418 } 419 420 void qemu_service_io(void) 421 { 422 qemu_notify_event(); 423 } 424 425 #ifdef HAS_AUDIO 426 struct soundhw soundhw[] = { 427 #ifdef HAS_AUDIO_CHOICE 428 #if defined(TARGET_I386) || defined(TARGET_MIPS) 429 { 430 "pcspk", 431 "PC speaker", 432 0, 433 1, 434 { .init_isa = pcspk_audio_init } 435 }, 436 #endif 437 438 #ifdef CONFIG_SB16 439 { 440 "sb16", 441 "Creative Sound Blaster 16", 442 0, 443 1, 444 { .init_isa = SB16_init } 445 }, 446 #endif 447 448 #ifdef CONFIG_CS4231A 449 { 450 "cs4231a", 451 "CS4231A", 452 0, 453 1, 454 { .init_isa = cs4231a_init } 455 }, 456 #endif 457 458 #ifdef CONFIG_ADLIB 459 { 460 "adlib", 461 #ifdef HAS_YMF262 462 "Yamaha YMF262 (OPL3)", 463 #else 464 "Yamaha YM3812 (OPL2)", 465 #endif 466 0, 467 1, 468 { .init_isa = Adlib_init } 469 }, 470 #endif 471 472 #ifdef CONFIG_GUS 473 { 474 "gus", 475 "Gravis Ultrasound GF1", 476 0, 477 1, 478 { .init_isa = GUS_init } 479 }, 480 #endif 481 482 #ifdef CONFIG_AC97 483 { 484 "ac97", 485 "Intel 82801AA AC97 Audio", 486 0, 487 0, 488 { .init_pci = ac97_init } 489 }, 490 #endif 491 492 #ifdef CONFIG_ES1370 493 { 494 "es1370", 495 "ENSONIQ AudioPCI ES1370", 496 0, 497 0, 498 { .init_pci = es1370_init } 499 }, 500 #endif 501 502 #ifdef CONFIG_HDA 503 { 504 "hda", 505 "Intel HD Audio", 506 0, 507 0, 508 { .init_pci = intel_hda_and_codec_init } 509 }, 510 #endif 511 512 #endif /* HAS_AUDIO_CHOICE */ 513 514 { NULL, NULL, 0, 0, { NULL } } 515 }; 516 517 void select_soundhw(const char *optarg) 518 { 519 struct soundhw *c; 520 521 if (*optarg == '?') { 522 show_valid_cards: 523 524 printf("Valid sound card names (comma separated):\n"); 525 for (c = soundhw; c->name; ++c) { 526 printf ("%-11s %s\n", c->name, c->descr); 527 } 528 printf("\n-soundhw all will enable all of the above\n"); 529 exit(*optarg != '?'); 530 } 531 else { 532 size_t l; 533 const char *p; 534 char *e; 535 int bad_card = 0; 536 537 if (!strcmp(optarg, "all")) { 538 for (c = soundhw; c->name; ++c) { 539 c->enabled = 1; 540 } 541 return; 542 } 543 544 p = optarg; 545 while (*p) { 546 e = strchr(p, ','); 547 l = !e ? strlen(p) : (size_t) (e - p); 548 549 for (c = soundhw; c->name; ++c) { 550 if (!strncmp(c->name, p, l) && !c->name[l]) { 551 c->enabled = 1; 552 break; 553 } 554 } 555 556 if (!c->name) { 557 if (l > 80) { 558 fprintf(stderr, 559 "Unknown sound card name (too big to show)\n"); 560 } 561 else { 562 fprintf(stderr, "Unknown sound card name `%.*s'\n", 563 (int) l, p); 564 } 565 bad_card = 1; 566 } 567 p += l + (e != NULL); 568 } 569 570 if (bad_card) { 571 goto show_valid_cards; 572 } 573 } 574 } 575 #else 576 void select_soundhw(const char *optarg) 577 { 578 } 579 #endif 580 581 int qemu_uuid_parse(const char *str, uint8_t *uuid) 582 { 583 int ret; 584 585 if (strlen(str) != 36) { 586 return -1; 587 } 588 589 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3], 590 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9], 591 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], 592 &uuid[15]); 593 594 if (ret != 16) { 595 return -1; 596 } 597 #ifdef TARGET_I386 598 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid); 599 #endif 600 return 0; 601 } 602 603 void do_acpitable_option(const char *optarg) 604 { 605 #ifdef TARGET_I386 606 if (acpi_table_add(optarg) < 0) { 607 fprintf(stderr, "Wrong acpi table provided\n"); 608 exit(1); 609 } 610 #endif 611 } 612 613 void do_smbios_option(const char *optarg) 614 { 615 #ifdef TARGET_I386 616 if (smbios_entry_add(optarg) < 0) { 617 fprintf(stderr, "Wrong smbios provided\n"); 618 exit(1); 619 } 620 #endif 621 } 622 623 void cpudef_init(void) 624 { 625 #if defined(cpudef_setup) 626 cpudef_setup(); /* parse cpu definitions in target config file */ 627 #endif 628 } 629 630 int audio_available(void) 631 { 632 #ifdef HAS_AUDIO 633 return 1; 634 #else 635 return 0; 636 #endif 637 } 638 639 int kvm_available(void) 640 { 641 #ifdef CONFIG_KVM 642 return 1; 643 #else 644 return 0; 645 #endif 646 } 647 648 int xen_available(void) 649 { 650 #ifdef CONFIG_XEN 651 return 1; 652 #else 653 return 0; 654 #endif 655 } 656