Annotation of qemu/arch_init.c, revision 1.1.1.5

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

unix.superglobalmegacorp.com