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
27 #include <sys/types.h>
33 #include "arch_init.h"
34 #include "audio/audio.h"
37 #include "hw/audiodev.h"
39 #include "migration.h"
42 #include "hw/smbios.h"
45 int graphic_width
= 1024;
46 int graphic_height
= 768;
47 int graphic_depth
= 8;
49 int graphic_width
= 800;
50 int graphic_height
= 600;
51 int graphic_depth
= 15;
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
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
91 static int is_dup_page(uint8_t *page
, uint8_t ch
)
93 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
94 uint32_t *array
= (uint32_t *)page
;
97 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
98 if (array
[i
] != val
) {
106 static int ram_save_block(QEMUFile
*f
)
108 static RAMBlock
*last_block
= NULL
;
109 static ram_addr_t last_offset
= 0;
110 RAMBlock
*block
= last_block
;
111 ram_addr_t offset
= last_offset
;
112 ram_addr_t current_addr
;
116 block
= QLIST_FIRST(&ram_list
.blocks
);
118 current_addr
= block
->offset
+ offset
;
121 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
124 cpu_physical_memory_reset_dirty(current_addr
,
125 current_addr
+ TARGET_PAGE_SIZE
,
126 MIGRATION_DIRTY_FLAG
);
128 p
= block
->host
+ offset
;
130 if (is_dup_page(p
, *p
)) {
131 qemu_put_be64(f
, offset
| RAM_SAVE_FLAG_COMPRESS
);
132 qemu_put_byte(f
, strlen(block
->idstr
));
133 qemu_put_buffer(f
, (uint8_t *)block
->idstr
,
134 strlen(block
->idstr
));
135 qemu_put_byte(f
, *p
);
138 qemu_put_be64(f
, offset
| RAM_SAVE_FLAG_PAGE
);
139 qemu_put_byte(f
, strlen(block
->idstr
));
140 qemu_put_buffer(f
, (uint8_t *)block
->idstr
,
141 strlen(block
->idstr
));
142 qemu_put_buffer(f
, p
, TARGET_PAGE_SIZE
);
143 bytes_sent
= TARGET_PAGE_SIZE
;
149 offset
+= TARGET_PAGE_SIZE
;
150 if (offset
>= block
->length
) {
152 block
= QLIST_NEXT(block
, next
);
154 block
= QLIST_FIRST(&ram_list
.blocks
);
157 current_addr
= block
->offset
+ offset
;
159 } while (current_addr
!= last_block
->offset
+ last_offset
);
162 last_offset
= offset
;
167 static uint64_t bytes_transferred
;
169 static ram_addr_t
ram_save_remaining(void)
172 ram_addr_t count
= 0;
174 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
176 for (addr
= block
->offset
; addr
< block
->offset
+ block
->length
;
177 addr
+= TARGET_PAGE_SIZE
) {
178 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
)) {
187 uint64_t ram_bytes_remaining(void)
189 return ram_save_remaining() * TARGET_PAGE_SIZE
;
192 uint64_t ram_bytes_transferred(void)
194 return bytes_transferred
;
197 uint64_t ram_bytes_total(void)
202 QLIST_FOREACH(block
, &ram_list
.blocks
, next
)
203 total
+= block
->length
;
208 int ram_save_live(Monitor
*mon
, QEMUFile
*f
, int stage
, void *opaque
)
211 uint64_t bytes_transferred_last
;
213 uint64_t expected_time
= 0;
216 cpu_physical_memory_set_dirty_tracking(0);
220 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX
) != 0) {
221 qemu_file_set_error(f
);
227 bytes_transferred
= 0;
229 /* Make sure all dirty bits are set */
230 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
231 for (addr
= block
->offset
; addr
< block
->offset
+ block
->length
;
232 addr
+= TARGET_PAGE_SIZE
) {
233 if (!cpu_physical_memory_get_dirty(addr
,
234 MIGRATION_DIRTY_FLAG
)) {
235 cpu_physical_memory_set_dirty(addr
);
240 /* Enable dirty memory tracking */
241 cpu_physical_memory_set_dirty_tracking(1);
243 qemu_put_be64(f
, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE
);
245 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
246 qemu_put_byte(f
, strlen(block
->idstr
));
247 qemu_put_buffer(f
, (uint8_t *)block
->idstr
, strlen(block
->idstr
));
248 qemu_put_be64(f
, block
->length
);
252 bytes_transferred_last
= bytes_transferred
;
253 bwidth
= qemu_get_clock_ns(rt_clock
);
255 while (!qemu_file_rate_limit(f
)) {
258 bytes_sent
= ram_save_block(f
);
259 bytes_transferred
+= bytes_sent
;
260 if (bytes_sent
== 0) { /* no more blocks */
265 bwidth
= qemu_get_clock_ns(rt_clock
) - bwidth
;
266 bwidth
= (bytes_transferred
- bytes_transferred_last
) / bwidth
;
268 /* if we haven't transferred anything this round, force expected_time to a
269 * a very high value, but without crashing */
274 /* try transferring iterative blocks of memory */
278 /* flush all remaining blocks regardless of rate limiting */
279 while ((bytes_sent
= ram_save_block(f
)) != 0) {
280 bytes_transferred
+= bytes_sent
;
282 cpu_physical_memory_set_dirty_tracking(0);
285 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
287 expected_time
= ram_save_remaining() * TARGET_PAGE_SIZE
/ bwidth
;
289 return (stage
== 2) && (expected_time
<= migrate_max_downtime());
292 int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
297 if (version_id
< 3 || version_id
> 4) {
302 addr
= qemu_get_be64(f
);
304 flags
= addr
& ~TARGET_PAGE_MASK
;
305 addr
&= TARGET_PAGE_MASK
;
307 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
308 if (version_id
== 3) {
309 if (addr
!= ram_bytes_total()) {
313 /* Synchronize RAM block list */
316 ram_addr_t total_ram_bytes
= addr
;
318 while (total_ram_bytes
) {
322 len
= qemu_get_byte(f
);
323 qemu_get_buffer(f
, (uint8_t *)id
, len
);
325 length
= qemu_get_be64(f
);
327 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
328 if (!strncmp(id
, block
->idstr
, sizeof(id
))) {
329 if (block
->length
!= length
)
336 if (!qemu_ram_alloc(NULL
, id
, length
))
340 total_ram_bytes
-= length
;
345 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
349 if (version_id
== 3) {
350 host
= qemu_get_ram_ptr(addr
);
356 len
= qemu_get_byte(f
);
357 qemu_get_buffer(f
, (uint8_t *)id
, len
);
360 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
361 if (!strncmp(id
, block
->idstr
, sizeof(id
)))
367 host
= block
->host
+ addr
;
369 ch
= qemu_get_byte(f
);
370 memset(host
, ch
, TARGET_PAGE_SIZE
);
373 (!kvm_enabled() || kvm_has_sync_mmu())) {
374 madvise(host
, TARGET_PAGE_SIZE
, MADV_DONTNEED
);
377 } else if (flags
& RAM_SAVE_FLAG_PAGE
) {
380 if (version_id
== 3) {
381 host
= qemu_get_ram_ptr(addr
);
387 len
= qemu_get_byte(f
);
388 qemu_get_buffer(f
, (uint8_t *)id
, len
);
391 QLIST_FOREACH(block
, &ram_list
.blocks
, next
) {
392 if (!strncmp(id
, block
->idstr
, sizeof(id
)))
398 host
= block
->host
+ addr
;
400 qemu_get_buffer(f
, host
, TARGET_PAGE_SIZE
);
402 if (qemu_file_has_error(f
)) {
405 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
410 void qemu_service_io(void)
416 struct soundhw soundhw
[] = {
417 #ifdef HAS_AUDIO_CHOICE
418 #if defined(TARGET_I386) || defined(TARGET_MIPS)
424 { .init_isa
= pcspk_audio_init
}
431 "Creative Sound Blaster 16",
434 { .init_isa
= SB16_init
}
438 #ifdef CONFIG_CS4231A
444 { .init_isa
= cs4231a_init
}
452 "Yamaha YMF262 (OPL3)",
454 "Yamaha YM3812 (OPL2)",
458 { .init_isa
= Adlib_init
}
465 "Gravis Ultrasound GF1",
468 { .init_isa
= GUS_init
}
475 "Intel 82801AA AC97 Audio",
478 { .init_pci
= ac97_init
}
485 "ENSONIQ AudioPCI ES1370",
488 { .init_pci
= es1370_init
}
492 #endif /* HAS_AUDIO_CHOICE */
494 { NULL
, NULL
, 0, 0, { NULL
} }
497 void select_soundhw(const char *optarg
)
501 if (*optarg
== '?') {
504 printf("Valid sound card names (comma separated):\n");
505 for (c
= soundhw
; c
->name
; ++c
) {
506 printf ("%-11s %s\n", c
->name
, c
->descr
);
508 printf("\n-soundhw all will enable all of the above\n");
509 exit(*optarg
!= '?');
517 if (!strcmp(optarg
, "all")) {
518 for (c
= soundhw
; c
->name
; ++c
) {
527 l
= !e
? strlen(p
) : (size_t) (e
- p
);
529 for (c
= soundhw
; c
->name
; ++c
) {
530 if (!strncmp(c
->name
, p
, l
) && !c
->name
[l
]) {
539 "Unknown sound card name (too big to show)\n");
542 fprintf(stderr
, "Unknown sound card name `%.*s'\n",
547 p
+= l
+ (e
!= NULL
);
551 goto show_valid_cards
;
556 void select_soundhw(const char *optarg
)
561 int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
565 if (strlen(str
) != 36) {
569 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
570 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
571 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14],
578 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
), 16, uuid
);
583 void do_acpitable_option(const char *optarg
)
586 if (acpi_table_add(optarg
) < 0) {
587 fprintf(stderr
, "Wrong acpi table provided\n");
593 void do_smbios_option(const char *optarg
)
596 if (smbios_entry_add(optarg
) < 0) {
597 fprintf(stderr
, "Wrong smbios provided\n");
603 void cpudef_init(void)
605 #if defined(cpudef_setup)
606 cpudef_setup(); /* parse cpu definitions in target config file */
610 int audio_available(void)
619 int kvm_available(void)
628 int xen_available(void)