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