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