Statistics
| Branch: | Revision:

root / arch_init.c @ d61a4ce8

History | View | Annotate | Download (15.9 kB)

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
#ifndef _WIN32
27
#include <sys/types.h>
28
#include <sys/mman.h>
29
#endif
30
#include "config.h"
31
#include "monitor.h"
32
#include "sysemu.h"
33
#include "arch_init.h"
34
#include "audio/audio.h"
35
#include "hw/pc.h"
36
#include "hw/pci.h"
37
#include "hw/audiodev.h"
38
#include "kvm.h"
39
#include "migration.h"
40
#include "net.h"
41
#include "gdbstub.h"
42
#include "hw/smbios.h"
43

    
44
#ifdef TARGET_SPARC
45
int graphic_width = 1024;
46
int graphic_height = 768;
47
int graphic_depth = 8;
48
#else
49
int graphic_width = 800;
50
int graphic_height = 600;
51
int graphic_depth = 15;
52
#endif
53

    
54
const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf";
55

    
56
#if defined(TARGET_ALPHA)
57
#define QEMU_ARCH QEMU_ARCH_ALPHA
58
#elif defined(TARGET_ARM)
59
#define QEMU_ARCH QEMU_ARCH_ARM
60
#elif defined(TARGET_CRIS)
61
#define QEMU_ARCH QEMU_ARCH_CRIS
62
#elif defined(TARGET_I386)
63
#define QEMU_ARCH QEMU_ARCH_I386
64
#elif defined(TARGET_M68K)
65
#define QEMU_ARCH QEMU_ARCH_M68K
66
#elif defined(TARGET_MICROBLAZE)
67
#define QEMU_ARCH QEMU_ARCH_MICROBLAZE
68
#elif defined(TARGET_MIPS)
69
#define QEMU_ARCH QEMU_ARCH_MIPS
70
#elif defined(TARGET_PPC)
71
#define QEMU_ARCH QEMU_ARCH_PPC
72
#elif defined(TARGET_S390X)
73
#define QEMU_ARCH QEMU_ARCH_S390X
74
#elif defined(TARGET_SH4)
75
#define QEMU_ARCH QEMU_ARCH_SH4
76
#elif defined(TARGET_SPARC)
77
#define QEMU_ARCH QEMU_ARCH_SPARC
78
#endif
79

    
80
const uint32_t arch_type = QEMU_ARCH;
81

    
82
/***********************************************************/
83
/* ram save/restore */
84

    
85
#define RAM_SAVE_FLAG_FULL     0x01 /* Obsolete, not used anymore */
86
#define RAM_SAVE_FLAG_COMPRESS 0x02
87
#define RAM_SAVE_FLAG_MEM_SIZE 0x04
88
#define RAM_SAVE_FLAG_PAGE     0x08
89
#define RAM_SAVE_FLAG_EOS      0x10
90
#define RAM_SAVE_FLAG_CONTINUE 0x20
91

    
92
static int is_dup_page(uint8_t *page, uint8_t ch)
93
{
94
    uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
95
    uint32_t *array = (uint32_t *)page;
96
    int i;
97

    
98
    for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
99
        if (array[i] != val) {
100
            return 0;
101
        }
102
    }
103

    
104
    return 1;
105
}
106

    
107
static RAMBlock *last_block;
108
static ram_addr_t last_offset;
109

    
110
static int ram_save_block(QEMUFile *f)
111
{
112
    RAMBlock *block = last_block;
113
    ram_addr_t offset = last_offset;
114
    ram_addr_t current_addr;
115
    int bytes_sent = 0;
116

    
117
    if (!block)
118
        block = QLIST_FIRST(&ram_list.blocks);
119

    
120
    current_addr = block->offset + offset;
121

    
122
    do {
123
        if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
124
            uint8_t *p;
125
            int cont = (block == last_block) ? RAM_SAVE_FLAG_CONTINUE : 0;
126

    
127
            cpu_physical_memory_reset_dirty(current_addr,
128
                                            current_addr + TARGET_PAGE_SIZE,
129
                                            MIGRATION_DIRTY_FLAG);
130

    
131
            p = block->host + offset;
132

    
133
            if (is_dup_page(p, *p)) {
134
                qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_COMPRESS);
135
                if (!cont) {
136
                    qemu_put_byte(f, strlen(block->idstr));
137
                    qemu_put_buffer(f, (uint8_t *)block->idstr,
138
                                    strlen(block->idstr));
139
                }
140
                qemu_put_byte(f, *p);
141
                bytes_sent = 1;
142
            } else {
143
                qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_PAGE);
144
                if (!cont) {
145
                    qemu_put_byte(f, strlen(block->idstr));
146
                    qemu_put_buffer(f, (uint8_t *)block->idstr,
147
                                    strlen(block->idstr));
148
                }
149
                qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
150
                bytes_sent = TARGET_PAGE_SIZE;
151
            }
152

    
153
            break;
154
        }
155

    
156
        offset += TARGET_PAGE_SIZE;
157
        if (offset >= block->length) {
158
            offset = 0;
159
            block = QLIST_NEXT(block, next);
160
            if (!block)
161
                block = QLIST_FIRST(&ram_list.blocks);
162
        }
163

    
164
        current_addr = block->offset + offset;
165

    
166
    } while (current_addr != last_block->offset + last_offset);
167

    
168
    last_block = block;
169
    last_offset = offset;
170

    
171
    return bytes_sent;
172
}
173

    
174
static uint64_t bytes_transferred;
175

    
176
static ram_addr_t ram_save_remaining(void)
177
{
178
    RAMBlock *block;
179
    ram_addr_t count = 0;
180

    
181
    QLIST_FOREACH(block, &ram_list.blocks, next) {
182
        ram_addr_t addr;
183
        for (addr = block->offset; addr < block->offset + block->length;
184
             addr += TARGET_PAGE_SIZE) {
185
            if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
186
                count++;
187
            }
188
        }
189
    }
190

    
191
    return count;
192
}
193

    
194
uint64_t ram_bytes_remaining(void)
195
{
196
    return ram_save_remaining() * TARGET_PAGE_SIZE;
197
}
198

    
199
uint64_t ram_bytes_transferred(void)
200
{
201
    return bytes_transferred;
202
}
203

    
204
uint64_t ram_bytes_total(void)
205
{
206
    RAMBlock *block;
207
    uint64_t total = 0;
208

    
209
    QLIST_FOREACH(block, &ram_list.blocks, next)
210
        total += block->length;
211

    
212
    return total;
213
}
214

    
215
int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
216
{
217
    ram_addr_t addr;
218
    uint64_t bytes_transferred_last;
219
    double bwidth = 0;
220
    uint64_t expected_time = 0;
221

    
222
    if (stage < 0) {
223
        cpu_physical_memory_set_dirty_tracking(0);
224
        return 0;
225
    }
226

    
227
    if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
228
        qemu_file_set_error(f);
229
        return 0;
230
    }
231

    
232
    if (stage == 1) {
233
        RAMBlock *block;
234
        bytes_transferred = 0;
235
        last_block = NULL;
236
        last_offset = 0;
237

    
238
        /* Make sure all dirty bits are set */
239
        QLIST_FOREACH(block, &ram_list.blocks, next) {
240
            for (addr = block->offset; addr < block->offset + block->length;
241
                 addr += TARGET_PAGE_SIZE) {
242
                if (!cpu_physical_memory_get_dirty(addr,
243
                                                   MIGRATION_DIRTY_FLAG)) {
244
                    cpu_physical_memory_set_dirty(addr);
245
                }
246
            }
247
        }
248

    
249
        /* Enable dirty memory tracking */
250
        cpu_physical_memory_set_dirty_tracking(1);
251

    
252
        qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
253

    
254
        QLIST_FOREACH(block, &ram_list.blocks, next) {
255
            qemu_put_byte(f, strlen(block->idstr));
256
            qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
257
            qemu_put_be64(f, block->length);
258
        }
259
    }
260

    
261
    bytes_transferred_last = bytes_transferred;
262
    bwidth = qemu_get_clock_ns(rt_clock);
263

    
264
    while (!qemu_file_rate_limit(f)) {
265
        int bytes_sent;
266

    
267
        bytes_sent = ram_save_block(f);
268
        bytes_transferred += bytes_sent;
269
        if (bytes_sent == 0) { /* no more blocks */
270
            break;
271
        }
272
    }
273

    
274
    bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
275
    bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
276

    
277
    /* if we haven't transferred anything this round, force expected_time to a
278
     * a very high value, but without crashing */
279
    if (bwidth == 0) {
280
        bwidth = 0.000001;
281
    }
282

    
283
    /* try transferring iterative blocks of memory */
284
    if (stage == 3) {
285
        int bytes_sent;
286

    
287
        /* flush all remaining blocks regardless of rate limiting */
288
        while ((bytes_sent = ram_save_block(f)) != 0) {
289
            bytes_transferred += bytes_sent;
290
        }
291
        cpu_physical_memory_set_dirty_tracking(0);
292
    }
293

    
294
    qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
295

    
296
    expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
297

    
298
    return (stage == 2) && (expected_time <= migrate_max_downtime());
299
}
300

    
301
static inline void *host_from_stream_offset(QEMUFile *f,
302
                                            ram_addr_t offset,
303
                                            int flags)
304
{
305
    static RAMBlock *block = NULL;
306
    char id[256];
307
    uint8_t len;
308

    
309
    if (flags & RAM_SAVE_FLAG_CONTINUE) {
310
        if (!block) {
311
            fprintf(stderr, "Ack, bad migration stream!\n");
312
            return NULL;
313
        }
314

    
315
        return block->host + offset;
316
    }
317

    
318
    len = qemu_get_byte(f);
319
    qemu_get_buffer(f, (uint8_t *)id, len);
320
    id[len] = 0;
321

    
322
    QLIST_FOREACH(block, &ram_list.blocks, next) {
323
        if (!strncmp(id, block->idstr, sizeof(id)))
324
            return block->host + offset;
325
    }
326

    
327
    fprintf(stderr, "Can't find block %s!\n", id);
328
    return NULL;
329
}
330

    
331
int ram_load(QEMUFile *f, void *opaque, int version_id)
332
{
333
    ram_addr_t addr;
334
    int flags;
335

    
336
    if (version_id < 3 || version_id > 4) {
337
        return -EINVAL;
338
    }
339

    
340
    do {
341
        addr = qemu_get_be64(f);
342

    
343
        flags = addr & ~TARGET_PAGE_MASK;
344
        addr &= TARGET_PAGE_MASK;
345

    
346
        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
347
            if (version_id == 3) {
348
                if (addr != ram_bytes_total()) {
349
                    return -EINVAL;
350
                }
351
            } else {
352
                /* Synchronize RAM block list */
353
                char id[256];
354
                ram_addr_t length;
355
                ram_addr_t total_ram_bytes = addr;
356

    
357
                while (total_ram_bytes) {
358
                    RAMBlock *block;
359
                    uint8_t len;
360

    
361
                    len = qemu_get_byte(f);
362
                    qemu_get_buffer(f, (uint8_t *)id, len);
363
                    id[len] = 0;
364
                    length = qemu_get_be64(f);
365

    
366
                    QLIST_FOREACH(block, &ram_list.blocks, next) {
367
                        if (!strncmp(id, block->idstr, sizeof(id))) {
368
                            if (block->length != length)
369
                                return -EINVAL;
370
                            break;
371
                        }
372
                    }
373

    
374
                    if (!block) {
375
                        fprintf(stderr, "Unknown ramblock \"%s\", cannot "
376
                                "accept migration\n", id);
377
                        return -EINVAL;
378
                    }
379

    
380
                    total_ram_bytes -= length;
381
                }
382
            }
383
        }
384

    
385
        if (flags & RAM_SAVE_FLAG_COMPRESS) {
386
            void *host;
387
            uint8_t ch;
388

    
389
            if (version_id == 3)
390
                host = qemu_get_ram_ptr(addr);
391
            else
392
                host = host_from_stream_offset(f, addr, flags);
393

    
394
            ch = qemu_get_byte(f);
395
            memset(host, ch, TARGET_PAGE_SIZE);
396
#ifndef _WIN32
397
            if (ch == 0 &&
398
                (!kvm_enabled() || kvm_has_sync_mmu())) {
399
                qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED);
400
            }
401
#endif
402
        } else if (flags & RAM_SAVE_FLAG_PAGE) {
403
            void *host;
404

    
405
            if (version_id == 3)
406
                host = qemu_get_ram_ptr(addr);
407
            else
408
                host = host_from_stream_offset(f, addr, flags);
409

    
410
            qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
411
        }
412
        if (qemu_file_has_error(f)) {
413
            return -EIO;
414
        }
415
    } while (!(flags & RAM_SAVE_FLAG_EOS));
416

    
417
    return 0;
418
}
419

    
420
void qemu_service_io(void)
421
{
422
    qemu_notify_event();
423
}
424

    
425
#ifdef HAS_AUDIO
426
struct soundhw soundhw[] = {
427
#ifdef HAS_AUDIO_CHOICE
428
#if defined(TARGET_I386) || defined(TARGET_MIPS)
429
    {
430
        "pcspk",
431
        "PC speaker",
432
        0,
433
        1,
434
        { .init_isa = pcspk_audio_init }
435
    },
436
#endif
437

    
438
#ifdef CONFIG_SB16
439
    {
440
        "sb16",
441
        "Creative Sound Blaster 16",
442
        0,
443
        1,
444
        { .init_isa = SB16_init }
445
    },
446
#endif
447

    
448
#ifdef CONFIG_CS4231A
449
    {
450
        "cs4231a",
451
        "CS4231A",
452
        0,
453
        1,
454
        { .init_isa = cs4231a_init }
455
    },
456
#endif
457

    
458
#ifdef CONFIG_ADLIB
459
    {
460
        "adlib",
461
#ifdef HAS_YMF262
462
        "Yamaha YMF262 (OPL3)",
463
#else
464
        "Yamaha YM3812 (OPL2)",
465
#endif
466
        0,
467
        1,
468
        { .init_isa = Adlib_init }
469
    },
470
#endif
471

    
472
#ifdef CONFIG_GUS
473
    {
474
        "gus",
475
        "Gravis Ultrasound GF1",
476
        0,
477
        1,
478
        { .init_isa = GUS_init }
479
    },
480
#endif
481

    
482
#ifdef CONFIG_AC97
483
    {
484
        "ac97",
485
        "Intel 82801AA AC97 Audio",
486
        0,
487
        0,
488
        { .init_pci = ac97_init }
489
    },
490
#endif
491

    
492
#ifdef CONFIG_ES1370
493
    {
494
        "es1370",
495
        "ENSONIQ AudioPCI ES1370",
496
        0,
497
        0,
498
        { .init_pci = es1370_init }
499
    },
500
#endif
501

    
502
#ifdef CONFIG_HDA
503
    {
504
        "hda",
505
        "Intel HD Audio",
506
        0,
507
        0,
508
        { .init_pci = intel_hda_and_codec_init }
509
    },
510
#endif
511

    
512
#endif /* HAS_AUDIO_CHOICE */
513

    
514
    { NULL, NULL, 0, 0, { NULL } }
515
};
516

    
517
void select_soundhw(const char *optarg)
518
{
519
    struct soundhw *c;
520

    
521
    if (*optarg == '?') {
522
    show_valid_cards:
523

    
524
        printf("Valid sound card names (comma separated):\n");
525
        for (c = soundhw; c->name; ++c) {
526
            printf ("%-11s %s\n", c->name, c->descr);
527
        }
528
        printf("\n-soundhw all will enable all of the above\n");
529
        exit(*optarg != '?');
530
    }
531
    else {
532
        size_t l;
533
        const char *p;
534
        char *e;
535
        int bad_card = 0;
536

    
537
        if (!strcmp(optarg, "all")) {
538
            for (c = soundhw; c->name; ++c) {
539
                c->enabled = 1;
540
            }
541
            return;
542
        }
543

    
544
        p = optarg;
545
        while (*p) {
546
            e = strchr(p, ',');
547
            l = !e ? strlen(p) : (size_t) (e - p);
548

    
549
            for (c = soundhw; c->name; ++c) {
550
                if (!strncmp(c->name, p, l) && !c->name[l]) {
551
                    c->enabled = 1;
552
                    break;
553
                }
554
            }
555

    
556
            if (!c->name) {
557
                if (l > 80) {
558
                    fprintf(stderr,
559
                            "Unknown sound card name (too big to show)\n");
560
                }
561
                else {
562
                    fprintf(stderr, "Unknown sound card name `%.*s'\n",
563
                            (int) l, p);
564
                }
565
                bad_card = 1;
566
            }
567
            p += l + (e != NULL);
568
        }
569

    
570
        if (bad_card) {
571
            goto show_valid_cards;
572
        }
573
    }
574
}
575
#else
576
void select_soundhw(const char *optarg)
577
{
578
}
579
#endif
580

    
581
int qemu_uuid_parse(const char *str, uint8_t *uuid)
582
{
583
    int ret;
584

    
585
    if (strlen(str) != 36) {
586
        return -1;
587
    }
588

    
589
    ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
590
                 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
591
                 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
592
                 &uuid[15]);
593

    
594
    if (ret != 16) {
595
        return -1;
596
    }
597
#ifdef TARGET_I386
598
    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
599
#endif
600
    return 0;
601
}
602

    
603
void do_acpitable_option(const char *optarg)
604
{
605
#ifdef TARGET_I386
606
    if (acpi_table_add(optarg) < 0) {
607
        fprintf(stderr, "Wrong acpi table provided\n");
608
        exit(1);
609
    }
610
#endif
611
}
612

    
613
void do_smbios_option(const char *optarg)
614
{
615
#ifdef TARGET_I386
616
    if (smbios_entry_add(optarg) < 0) {
617
        fprintf(stderr, "Wrong smbios provided\n");
618
        exit(1);
619
    }
620
#endif
621
}
622

    
623
void cpudef_init(void)
624
{
625
#if defined(cpudef_setup)
626
    cpudef_setup(); /* parse cpu definitions in target config file */
627
#endif
628
}
629

    
630
int audio_available(void)
631
{
632
#ifdef HAS_AUDIO
633
    return 1;
634
#else
635
    return 0;
636
#endif
637
}
638

    
639
int kvm_available(void)
640
{
641
#ifdef CONFIG_KVM
642
    return 1;
643
#else
644
    return 0;
645
#endif
646
}
647

    
648
int xen_available(void)
649
{
650
#ifdef CONFIG_XEN
651
    return 1;
652
#else
653
    return 0;
654
#endif
655
}