pci: introduce helper function to handle msi-x and msi.
[qemu.git] / arch_init.c
blob47bb4b2d8fc141e4d1fd923baf9848039219a4e2
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
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"
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
54 const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf";
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
80 const uint32_t arch_type = QEMU_ARCH;
82 /***********************************************************/
83 /* ram save/restore */
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
92 static int is_dup_page(uint8_t *page, uint8_t ch)
94 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
95 uint32_t *array = (uint32_t *)page;
96 int i;
98 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
99 if (array[i] != val) {
100 return 0;
104 return 1;
107 static int ram_save_block(QEMUFile *f)
109 static RAMBlock *last_block = NULL;
110 static ram_addr_t last_offset = 0;
111 RAMBlock *block = last_block;
112 ram_addr_t offset = last_offset;
113 ram_addr_t current_addr;
114 int bytes_sent = 0;
116 if (!block)
117 block = QLIST_FIRST(&ram_list.blocks);
119 current_addr = block->offset + offset;
121 do {
122 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
123 uint8_t *p;
124 int cont = (block == last_block) ? RAM_SAVE_FLAG_CONTINUE : 0;
126 cpu_physical_memory_reset_dirty(current_addr,
127 current_addr + TARGET_PAGE_SIZE,
128 MIGRATION_DIRTY_FLAG);
130 p = block->host + offset;
132 if (is_dup_page(p, *p)) {
133 qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_COMPRESS);
134 if (!cont) {
135 qemu_put_byte(f, strlen(block->idstr));
136 qemu_put_buffer(f, (uint8_t *)block->idstr,
137 strlen(block->idstr));
139 qemu_put_byte(f, *p);
140 bytes_sent = 1;
141 } else {
142 qemu_put_be64(f, offset | cont | RAM_SAVE_FLAG_PAGE);
143 if (!cont) {
144 qemu_put_byte(f, strlen(block->idstr));
145 qemu_put_buffer(f, (uint8_t *)block->idstr,
146 strlen(block->idstr));
148 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
149 bytes_sent = TARGET_PAGE_SIZE;
152 break;
155 offset += TARGET_PAGE_SIZE;
156 if (offset >= block->length) {
157 offset = 0;
158 block = QLIST_NEXT(block, next);
159 if (!block)
160 block = QLIST_FIRST(&ram_list.blocks);
163 current_addr = block->offset + offset;
165 } while (current_addr != last_block->offset + last_offset);
167 last_block = block;
168 last_offset = offset;
170 return bytes_sent;
173 static uint64_t bytes_transferred;
175 static ram_addr_t ram_save_remaining(void)
177 RAMBlock *block;
178 ram_addr_t count = 0;
180 QLIST_FOREACH(block, &ram_list.blocks, next) {
181 ram_addr_t addr;
182 for (addr = block->offset; addr < block->offset + block->length;
183 addr += TARGET_PAGE_SIZE) {
184 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
185 count++;
190 return count;
193 uint64_t ram_bytes_remaining(void)
195 return ram_save_remaining() * TARGET_PAGE_SIZE;
198 uint64_t ram_bytes_transferred(void)
200 return bytes_transferred;
203 uint64_t ram_bytes_total(void)
205 RAMBlock *block;
206 uint64_t total = 0;
208 QLIST_FOREACH(block, &ram_list.blocks, next)
209 total += block->length;
211 return total;
214 int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
216 ram_addr_t addr;
217 uint64_t bytes_transferred_last;
218 double bwidth = 0;
219 uint64_t expected_time = 0;
221 if (stage < 0) {
222 cpu_physical_memory_set_dirty_tracking(0);
223 return 0;
226 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
227 qemu_file_set_error(f);
228 return 0;
231 if (stage == 1) {
232 RAMBlock *block;
233 bytes_transferred = 0;
235 /* Make sure all dirty bits are set */
236 QLIST_FOREACH(block, &ram_list.blocks, next) {
237 for (addr = block->offset; addr < block->offset + block->length;
238 addr += TARGET_PAGE_SIZE) {
239 if (!cpu_physical_memory_get_dirty(addr,
240 MIGRATION_DIRTY_FLAG)) {
241 cpu_physical_memory_set_dirty(addr);
246 /* Enable dirty memory tracking */
247 cpu_physical_memory_set_dirty_tracking(1);
249 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
251 QLIST_FOREACH(block, &ram_list.blocks, next) {
252 qemu_put_byte(f, strlen(block->idstr));
253 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
254 qemu_put_be64(f, block->length);
258 bytes_transferred_last = bytes_transferred;
259 bwidth = qemu_get_clock_ns(rt_clock);
261 while (!qemu_file_rate_limit(f)) {
262 int bytes_sent;
264 bytes_sent = ram_save_block(f);
265 bytes_transferred += bytes_sent;
266 if (bytes_sent == 0) { /* no more blocks */
267 break;
271 bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
272 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
274 /* if we haven't transferred anything this round, force expected_time to a
275 * a very high value, but without crashing */
276 if (bwidth == 0) {
277 bwidth = 0.000001;
280 /* try transferring iterative blocks of memory */
281 if (stage == 3) {
282 int bytes_sent;
284 /* flush all remaining blocks regardless of rate limiting */
285 while ((bytes_sent = ram_save_block(f)) != 0) {
286 bytes_transferred += bytes_sent;
288 cpu_physical_memory_set_dirty_tracking(0);
291 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
293 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
295 return (stage == 2) && (expected_time <= migrate_max_downtime());
298 static inline void *host_from_stream_offset(QEMUFile *f,
299 ram_addr_t offset,
300 int flags)
302 static RAMBlock *block = NULL;
303 char id[256];
304 uint8_t len;
306 if (flags & RAM_SAVE_FLAG_CONTINUE) {
307 if (!block) {
308 fprintf(stderr, "Ack, bad migration stream!\n");
309 return NULL;
312 return block->host + offset;
315 len = qemu_get_byte(f);
316 qemu_get_buffer(f, (uint8_t *)id, len);
317 id[len] = 0;
319 QLIST_FOREACH(block, &ram_list.blocks, next) {
320 if (!strncmp(id, block->idstr, sizeof(id)))
321 return block->host + offset;
324 fprintf(stderr, "Can't find block %s!\n", id);
325 return NULL;
328 int ram_load(QEMUFile *f, void *opaque, int version_id)
330 ram_addr_t addr;
331 int flags;
333 if (version_id < 3 || version_id > 4) {
334 return -EINVAL;
337 do {
338 addr = qemu_get_be64(f);
340 flags = addr & ~TARGET_PAGE_MASK;
341 addr &= TARGET_PAGE_MASK;
343 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
344 if (version_id == 3) {
345 if (addr != ram_bytes_total()) {
346 return -EINVAL;
348 } else {
349 /* Synchronize RAM block list */
350 char id[256];
351 ram_addr_t length;
352 ram_addr_t total_ram_bytes = addr;
354 while (total_ram_bytes) {
355 RAMBlock *block;
356 uint8_t len;
358 len = qemu_get_byte(f);
359 qemu_get_buffer(f, (uint8_t *)id, len);
360 id[len] = 0;
361 length = qemu_get_be64(f);
363 QLIST_FOREACH(block, &ram_list.blocks, next) {
364 if (!strncmp(id, block->idstr, sizeof(id))) {
365 if (block->length != length)
366 return -EINVAL;
367 break;
371 if (!block) {
372 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
373 "accept migration\n", id);
374 return -EINVAL;
377 total_ram_bytes -= length;
382 if (flags & RAM_SAVE_FLAG_COMPRESS) {
383 void *host;
384 uint8_t ch;
386 if (version_id == 3)
387 host = qemu_get_ram_ptr(addr);
388 else
389 host = host_from_stream_offset(f, addr, flags);
391 ch = qemu_get_byte(f);
392 memset(host, ch, TARGET_PAGE_SIZE);
393 #ifndef _WIN32
394 if (ch == 0 &&
395 (!kvm_enabled() || kvm_has_sync_mmu())) {
396 madvise(host, TARGET_PAGE_SIZE, MADV_DONTNEED);
398 #endif
399 } else if (flags & RAM_SAVE_FLAG_PAGE) {
400 void *host;
402 if (version_id == 3)
403 host = qemu_get_ram_ptr(addr);
404 else
405 host = host_from_stream_offset(f, addr, flags);
407 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
409 if (qemu_file_has_error(f)) {
410 return -EIO;
412 } while (!(flags & RAM_SAVE_FLAG_EOS));
414 return 0;
417 void qemu_service_io(void)
419 qemu_notify_event();
422 #ifdef HAS_AUDIO
423 struct soundhw soundhw[] = {
424 #ifdef HAS_AUDIO_CHOICE
425 #if defined(TARGET_I386) || defined(TARGET_MIPS)
427 "pcspk",
428 "PC speaker",
431 { .init_isa = pcspk_audio_init }
433 #endif
435 #ifdef CONFIG_SB16
437 "sb16",
438 "Creative Sound Blaster 16",
441 { .init_isa = SB16_init }
443 #endif
445 #ifdef CONFIG_CS4231A
447 "cs4231a",
448 "CS4231A",
451 { .init_isa = cs4231a_init }
453 #endif
455 #ifdef CONFIG_ADLIB
457 "adlib",
458 #ifdef HAS_YMF262
459 "Yamaha YMF262 (OPL3)",
460 #else
461 "Yamaha YM3812 (OPL2)",
462 #endif
465 { .init_isa = Adlib_init }
467 #endif
469 #ifdef CONFIG_GUS
471 "gus",
472 "Gravis Ultrasound GF1",
475 { .init_isa = GUS_init }
477 #endif
479 #ifdef CONFIG_AC97
481 "ac97",
482 "Intel 82801AA AC97 Audio",
485 { .init_pci = ac97_init }
487 #endif
489 #ifdef CONFIG_ES1370
491 "es1370",
492 "ENSONIQ AudioPCI ES1370",
495 { .init_pci = es1370_init }
497 #endif
499 #endif /* HAS_AUDIO_CHOICE */
501 { NULL, NULL, 0, 0, { NULL } }
504 void select_soundhw(const char *optarg)
506 struct soundhw *c;
508 if (*optarg == '?') {
509 show_valid_cards:
511 printf("Valid sound card names (comma separated):\n");
512 for (c = soundhw; c->name; ++c) {
513 printf ("%-11s %s\n", c->name, c->descr);
515 printf("\n-soundhw all will enable all of the above\n");
516 exit(*optarg != '?');
518 else {
519 size_t l;
520 const char *p;
521 char *e;
522 int bad_card = 0;
524 if (!strcmp(optarg, "all")) {
525 for (c = soundhw; c->name; ++c) {
526 c->enabled = 1;
528 return;
531 p = optarg;
532 while (*p) {
533 e = strchr(p, ',');
534 l = !e ? strlen(p) : (size_t) (e - p);
536 for (c = soundhw; c->name; ++c) {
537 if (!strncmp(c->name, p, l) && !c->name[l]) {
538 c->enabled = 1;
539 break;
543 if (!c->name) {
544 if (l > 80) {
545 fprintf(stderr,
546 "Unknown sound card name (too big to show)\n");
548 else {
549 fprintf(stderr, "Unknown sound card name `%.*s'\n",
550 (int) l, p);
552 bad_card = 1;
554 p += l + (e != NULL);
557 if (bad_card) {
558 goto show_valid_cards;
562 #else
563 void select_soundhw(const char *optarg)
566 #endif
568 int qemu_uuid_parse(const char *str, uint8_t *uuid)
570 int ret;
572 if (strlen(str) != 36) {
573 return -1;
576 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
577 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
578 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
579 &uuid[15]);
581 if (ret != 16) {
582 return -1;
584 #ifdef TARGET_I386
585 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
586 #endif
587 return 0;
590 void do_acpitable_option(const char *optarg)
592 #ifdef TARGET_I386
593 if (acpi_table_add(optarg) < 0) {
594 fprintf(stderr, "Wrong acpi table provided\n");
595 exit(1);
597 #endif
600 void do_smbios_option(const char *optarg)
602 #ifdef TARGET_I386
603 if (smbios_entry_add(optarg) < 0) {
604 fprintf(stderr, "Wrong smbios provided\n");
605 exit(1);
607 #endif
610 void cpudef_init(void)
612 #if defined(cpudef_setup)
613 cpudef_setup(); /* parse cpu definitions in target config file */
614 #endif
617 int audio_available(void)
619 #ifdef HAS_AUDIO
620 return 1;
621 #else
622 return 0;
623 #endif
626 int kvm_available(void)
628 #ifdef CONFIG_KVM
629 return 1;
630 #else
631 return 0;
632 #endif
635 int xen_available(void)
637 #ifdef CONFIG_XEN
638 return 1;
639 #else
640 return 0;
641 #endif