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