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