Merge branch 'upstream-merge'
[qemu-kvm.git] / arch_init.c
blob9904f95478d4dd98a7ba8efe00c258fd30b262bf
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 #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/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"
44 #include "exec-memory.h"
45 #include "hw/pcspk.h"
46 #include "qemu/page_cache.h"
47 #include "qmp-commands.h"
49 #ifdef DEBUG_ARCH_INIT
50 #define DPRINTF(fmt, ...) \
51 do { fprintf(stdout, "arch_init: " fmt, ## __VA_ARGS__); } while (0)
52 #else
53 #define DPRINTF(fmt, ...) \
54 do { } while (0)
55 #endif
57 #ifdef TARGET_SPARC
58 int graphic_width = 1024;
59 int graphic_height = 768;
60 int graphic_depth = 8;
61 #else
62 int graphic_width = 800;
63 int graphic_height = 600;
64 int graphic_depth = 15;
65 #endif
68 #if defined(TARGET_ALPHA)
69 #define QEMU_ARCH QEMU_ARCH_ALPHA
70 #elif defined(TARGET_ARM)
71 #define QEMU_ARCH QEMU_ARCH_ARM
72 #elif defined(TARGET_CRIS)
73 #define QEMU_ARCH QEMU_ARCH_CRIS
74 #elif defined(TARGET_I386)
75 #define QEMU_ARCH QEMU_ARCH_I386
76 #elif defined(TARGET_M68K)
77 #define QEMU_ARCH QEMU_ARCH_M68K
78 #elif defined(TARGET_LM32)
79 #define QEMU_ARCH QEMU_ARCH_LM32
80 #elif defined(TARGET_MICROBLAZE)
81 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE
82 #elif defined(TARGET_MIPS)
83 #define QEMU_ARCH QEMU_ARCH_MIPS
84 #elif defined(TARGET_OPENRISC)
85 #define QEMU_ARCH QEMU_ARCH_OPENRISC
86 #elif defined(TARGET_PPC)
87 #define QEMU_ARCH QEMU_ARCH_PPC
88 #elif defined(TARGET_S390X)
89 #define QEMU_ARCH QEMU_ARCH_S390X
90 #elif defined(TARGET_SH4)
91 #define QEMU_ARCH QEMU_ARCH_SH4
92 #elif defined(TARGET_SPARC)
93 #define QEMU_ARCH QEMU_ARCH_SPARC
94 #elif defined(TARGET_XTENSA)
95 #define QEMU_ARCH QEMU_ARCH_XTENSA
96 #elif defined(TARGET_UNICORE32)
97 #define QEMU_ARCH QEMU_ARCH_UNICORE32
98 #endif
100 const uint32_t arch_type = QEMU_ARCH;
102 /***********************************************************/
103 /* ram save/restore */
105 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
106 #define RAM_SAVE_FLAG_COMPRESS 0x02
107 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
108 #define RAM_SAVE_FLAG_PAGE 0x08
109 #define RAM_SAVE_FLAG_EOS 0x10
110 #define RAM_SAVE_FLAG_CONTINUE 0x20
111 #define RAM_SAVE_FLAG_XBZRLE 0x40
113 #ifdef __ALTIVEC__
114 #include <altivec.h>
115 #define VECTYPE vector unsigned char
116 #define SPLAT(p) vec_splat(vec_ld(0, p), 0)
117 #define ALL_EQ(v1, v2) vec_all_eq(v1, v2)
118 /* altivec.h may redefine the bool macro as vector type.
119 * Reset it to POSIX semantics. */
120 #undef bool
121 #define bool _Bool
122 #elif defined __SSE2__
123 #include <emmintrin.h>
124 #define VECTYPE __m128i
125 #define SPLAT(p) _mm_set1_epi8(*(p))
126 #define ALL_EQ(v1, v2) (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) == 0xFFFF)
127 #else
128 #define VECTYPE unsigned long
129 #define SPLAT(p) (*(p) * (~0UL / 255))
130 #define ALL_EQ(v1, v2) ((v1) == (v2))
131 #endif
134 static struct defconfig_file {
135 const char *filename;
136 /* Indicates it is an user config file (disabled by -no-user-config) */
137 bool userconfig;
138 } default_config_files[] = {
139 { CONFIG_QEMU_CONFDIR "/qemu.conf", true },
140 { CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", true },
141 { NULL }, /* end of list */
145 int qemu_read_default_config_files(bool userconfig)
147 int ret;
148 struct defconfig_file *f;
150 for (f = default_config_files; f->filename; f++) {
151 if (!userconfig && f->userconfig) {
152 continue;
154 ret = qemu_read_config_file(f->filename);
155 if (ret < 0 && ret != -ENOENT) {
156 return ret;
160 return 0;
163 static int is_dup_page(uint8_t *page)
165 VECTYPE *p = (VECTYPE *)page;
166 VECTYPE val = SPLAT(page);
167 int i;
169 for (i = 0; i < TARGET_PAGE_SIZE / sizeof(VECTYPE); i++) {
170 if (!ALL_EQ(val, p[i])) {
171 return 0;
175 return 1;
178 /* struct contains XBZRLE cache and a static page
179 used by the compression */
180 static struct {
181 /* buffer used for XBZRLE encoding */
182 uint8_t *encoded_buf;
183 /* buffer for storing page content */
184 uint8_t *current_buf;
185 /* buffer used for XBZRLE decoding */
186 uint8_t *decoded_buf;
187 /* Cache for XBZRLE */
188 PageCache *cache;
189 } XBZRLE = {
190 .encoded_buf = NULL,
191 .current_buf = NULL,
192 .decoded_buf = NULL,
193 .cache = NULL,
197 int64_t xbzrle_cache_resize(int64_t new_size)
199 if (XBZRLE.cache != NULL) {
200 return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) *
201 TARGET_PAGE_SIZE;
203 return pow2floor(new_size);
206 /* accounting for migration statistics */
207 typedef struct AccountingInfo {
208 uint64_t dup_pages;
209 uint64_t norm_pages;
210 uint64_t iterations;
211 uint64_t xbzrle_bytes;
212 uint64_t xbzrle_pages;
213 uint64_t xbzrle_cache_miss;
214 uint64_t xbzrle_overflows;
215 } AccountingInfo;
217 static AccountingInfo acct_info;
219 static void acct_clear(void)
221 memset(&acct_info, 0, sizeof(acct_info));
224 uint64_t dup_mig_bytes_transferred(void)
226 return acct_info.dup_pages * TARGET_PAGE_SIZE;
229 uint64_t dup_mig_pages_transferred(void)
231 return acct_info.dup_pages;
234 uint64_t norm_mig_bytes_transferred(void)
236 return acct_info.norm_pages * TARGET_PAGE_SIZE;
239 uint64_t norm_mig_pages_transferred(void)
241 return acct_info.norm_pages;
244 uint64_t xbzrle_mig_bytes_transferred(void)
246 return acct_info.xbzrle_bytes;
249 uint64_t xbzrle_mig_pages_transferred(void)
251 return acct_info.xbzrle_pages;
254 uint64_t xbzrle_mig_pages_cache_miss(void)
256 return acct_info.xbzrle_cache_miss;
259 uint64_t xbzrle_mig_pages_overflow(void)
261 return acct_info.xbzrle_overflows;
264 static void save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
265 int cont, int flag)
267 qemu_put_be64(f, offset | cont | flag);
268 if (!cont) {
269 qemu_put_byte(f, strlen(block->idstr));
270 qemu_put_buffer(f, (uint8_t *)block->idstr,
271 strlen(block->idstr));
276 #define ENCODING_FLAG_XBZRLE 0x1
278 static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
279 ram_addr_t current_addr, RAMBlock *block,
280 ram_addr_t offset, int cont, bool last_stage)
282 int encoded_len = 0, bytes_sent = -1;
283 uint8_t *prev_cached_page;
285 if (!cache_is_cached(XBZRLE.cache, current_addr)) {
286 if (!last_stage) {
287 cache_insert(XBZRLE.cache, current_addr,
288 g_memdup(current_data, TARGET_PAGE_SIZE));
290 acct_info.xbzrle_cache_miss++;
291 return -1;
294 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
296 /* save current buffer into memory */
297 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE);
299 /* XBZRLE encoding (if there is no overflow) */
300 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
301 TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
302 TARGET_PAGE_SIZE);
303 if (encoded_len == 0) {
304 DPRINTF("Skipping unmodified page\n");
305 return 0;
306 } else if (encoded_len == -1) {
307 DPRINTF("Overflow\n");
308 acct_info.xbzrle_overflows++;
309 /* update data in the cache */
310 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE);
311 return -1;
314 /* we need to update the data in the cache, in order to get the same data */
315 if (!last_stage) {
316 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
319 /* Send XBZRLE based compressed page */
320 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
321 qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
322 qemu_put_be16(f, encoded_len);
323 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
324 bytes_sent = encoded_len + 1 + 2;
325 acct_info.xbzrle_pages++;
326 acct_info.xbzrle_bytes += bytes_sent;
328 return bytes_sent;
331 static RAMBlock *last_block;
332 static ram_addr_t last_offset;
335 * ram_save_block: Writes a page of memory to the stream f
337 * Returns: 0: if the page hasn't changed
338 * -1: if there are no more dirty pages
339 * n: the amount of bytes written in other case
342 static int ram_save_block(QEMUFile *f, bool last_stage)
344 RAMBlock *block = last_block;
345 ram_addr_t offset = last_offset;
346 int bytes_sent = -1;
347 MemoryRegion *mr;
348 ram_addr_t current_addr;
350 if (!block)
351 block = QLIST_FIRST(&ram_list.blocks);
353 do {
354 mr = block->mr;
355 if (memory_region_get_dirty(mr, offset, TARGET_PAGE_SIZE,
356 DIRTY_MEMORY_MIGRATION)) {
357 uint8_t *p;
358 int cont = (block == last_block) ? RAM_SAVE_FLAG_CONTINUE : 0;
360 memory_region_reset_dirty(mr, offset, TARGET_PAGE_SIZE,
361 DIRTY_MEMORY_MIGRATION);
363 p = memory_region_get_ram_ptr(mr) + offset;
365 if (is_dup_page(p)) {
366 acct_info.dup_pages++;
367 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_COMPRESS);
368 qemu_put_byte(f, *p);
369 bytes_sent = 1;
370 } else if (migrate_use_xbzrle()) {
371 current_addr = block->offset + offset;
372 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
373 offset, cont, last_stage);
374 if (!last_stage) {
375 p = get_cached_data(XBZRLE.cache, current_addr);
379 /* either we didn't send yet (we may have had XBZRLE overflow) */
380 if (bytes_sent == -1) {
381 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
382 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
383 bytes_sent = TARGET_PAGE_SIZE;
384 acct_info.norm_pages++;
387 /* if page is unmodified, continue to the next */
388 if (bytes_sent != 0) {
389 break;
393 offset += TARGET_PAGE_SIZE;
394 if (offset >= block->length) {
395 offset = 0;
396 block = QLIST_NEXT(block, next);
397 if (!block)
398 block = QLIST_FIRST(&ram_list.blocks);
400 } while (block != last_block || offset != last_offset);
402 last_block = block;
403 last_offset = offset;
405 return bytes_sent;
408 static uint64_t bytes_transferred;
410 static ram_addr_t ram_save_remaining(void)
412 return ram_list.dirty_pages;
415 uint64_t ram_bytes_remaining(void)
417 return ram_save_remaining() * TARGET_PAGE_SIZE;
420 uint64_t ram_bytes_transferred(void)
422 return bytes_transferred;
425 uint64_t ram_bytes_total(void)
427 RAMBlock *block;
428 uint64_t total = 0;
430 QLIST_FOREACH(block, &ram_list.blocks, next)
431 total += block->length;
433 return total;
436 static int block_compar(const void *a, const void *b)
438 RAMBlock * const *ablock = a;
439 RAMBlock * const *bblock = b;
441 return strcmp((*ablock)->idstr, (*bblock)->idstr);
444 static void sort_ram_list(void)
446 RAMBlock *block, *nblock, **blocks;
447 int n;
448 n = 0;
449 QLIST_FOREACH(block, &ram_list.blocks, next) {
450 ++n;
452 blocks = g_malloc(n * sizeof *blocks);
453 n = 0;
454 QLIST_FOREACH_SAFE(block, &ram_list.blocks, next, nblock) {
455 blocks[n++] = block;
456 QLIST_REMOVE(block, next);
458 qsort(blocks, n, sizeof *blocks, block_compar);
459 while (--n >= 0) {
460 QLIST_INSERT_HEAD(&ram_list.blocks, blocks[n], next);
462 g_free(blocks);
465 static void migration_end(void)
467 memory_global_dirty_log_stop();
469 if (migrate_use_xbzrle()) {
470 cache_fini(XBZRLE.cache);
471 g_free(XBZRLE.cache);
472 g_free(XBZRLE.encoded_buf);
473 g_free(XBZRLE.current_buf);
474 g_free(XBZRLE.decoded_buf);
475 XBZRLE.cache = NULL;
479 static void ram_migration_cancel(void *opaque)
481 migration_end();
484 #define MAX_WAIT 50 /* ms, half buffered_file limit */
486 static int ram_save_setup(QEMUFile *f, void *opaque)
488 ram_addr_t addr;
489 RAMBlock *block;
491 bytes_transferred = 0;
492 last_block = NULL;
493 last_offset = 0;
494 sort_ram_list();
496 if (migrate_use_xbzrle()) {
497 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
498 TARGET_PAGE_SIZE,
499 TARGET_PAGE_SIZE);
500 if (!XBZRLE.cache) {
501 DPRINTF("Error creating cache\n");
502 return -1;
504 XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE);
505 XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE);
506 acct_clear();
509 /* Make sure all dirty bits are set */
510 QLIST_FOREACH(block, &ram_list.blocks, next) {
511 for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) {
512 if (!memory_region_get_dirty(block->mr, addr, TARGET_PAGE_SIZE,
513 DIRTY_MEMORY_MIGRATION)) {
514 memory_region_set_dirty(block->mr, addr, TARGET_PAGE_SIZE);
519 memory_global_dirty_log_start();
521 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
523 QLIST_FOREACH(block, &ram_list.blocks, next) {
524 qemu_put_byte(f, strlen(block->idstr));
525 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
526 qemu_put_be64(f, block->length);
529 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
531 return 0;
534 static int ram_save_iterate(QEMUFile *f, void *opaque)
536 uint64_t bytes_transferred_last;
537 double bwidth = 0;
538 int ret;
539 int i;
540 uint64_t expected_time;
542 bytes_transferred_last = bytes_transferred;
543 bwidth = qemu_get_clock_ns(rt_clock);
545 i = 0;
546 while ((ret = qemu_file_rate_limit(f)) == 0) {
547 int bytes_sent;
549 bytes_sent = ram_save_block(f, false);
550 /* no more blocks to sent */
551 if (bytes_sent < 0) {
552 break;
554 bytes_transferred += bytes_sent;
555 acct_info.iterations++;
556 /* we want to check in the 1st loop, just in case it was the 1st time
557 and we had to sync the dirty bitmap.
558 qemu_get_clock_ns() is a bit expensive, so we only check each some
559 iterations
561 if ((i & 63) == 0) {
562 uint64_t t1 = (qemu_get_clock_ns(rt_clock) - bwidth) / 1000000;
563 if (t1 > MAX_WAIT) {
564 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
565 t1, i);
566 break;
569 i++;
572 if (ret < 0) {
573 return ret;
576 bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
577 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
579 /* if we haven't transferred anything this round, force expected_time to a
580 * a very high value, but without crashing */
581 if (bwidth == 0) {
582 bwidth = 0.000001;
585 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
587 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
589 DPRINTF("ram_save_live: expected(%" PRIu64 ") <= max(%" PRIu64 ")?\n",
590 expected_time, migrate_max_downtime());
592 if (expected_time <= migrate_max_downtime()) {
593 memory_global_sync_dirty_bitmap(get_system_memory());
594 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
596 return expected_time <= migrate_max_downtime();
598 return 0;
601 static int ram_save_complete(QEMUFile *f, void *opaque)
603 memory_global_sync_dirty_bitmap(get_system_memory());
605 /* try transferring iterative blocks of memory */
607 /* flush all remaining blocks regardless of rate limiting */
608 while (true) {
609 int bytes_sent;
611 bytes_sent = ram_save_block(f, true);
612 /* no more blocks to sent */
613 if (bytes_sent < 0) {
614 break;
616 bytes_transferred += bytes_sent;
618 memory_global_dirty_log_stop();
620 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
622 return 0;
625 static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
627 int ret, rc = 0;
628 unsigned int xh_len;
629 int xh_flags;
631 if (!XBZRLE.decoded_buf) {
632 XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE);
635 /* extract RLE header */
636 xh_flags = qemu_get_byte(f);
637 xh_len = qemu_get_be16(f);
639 if (xh_flags != ENCODING_FLAG_XBZRLE) {
640 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
641 return -1;
644 if (xh_len > TARGET_PAGE_SIZE) {
645 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
646 return -1;
648 /* load data and decode */
649 qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len);
651 /* decode RLE */
652 ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host,
653 TARGET_PAGE_SIZE);
654 if (ret == -1) {
655 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
656 rc = -1;
657 } else if (ret > TARGET_PAGE_SIZE) {
658 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
659 ret, TARGET_PAGE_SIZE);
660 abort();
663 return rc;
666 static inline void *host_from_stream_offset(QEMUFile *f,
667 ram_addr_t offset,
668 int flags)
670 static RAMBlock *block = NULL;
671 char id[256];
672 uint8_t len;
674 if (flags & RAM_SAVE_FLAG_CONTINUE) {
675 if (!block) {
676 fprintf(stderr, "Ack, bad migration stream!\n");
677 return NULL;
680 return memory_region_get_ram_ptr(block->mr) + offset;
683 len = qemu_get_byte(f);
684 qemu_get_buffer(f, (uint8_t *)id, len);
685 id[len] = 0;
687 QLIST_FOREACH(block, &ram_list.blocks, next) {
688 if (!strncmp(id, block->idstr, sizeof(id)))
689 return memory_region_get_ram_ptr(block->mr) + offset;
692 fprintf(stderr, "Can't find block %s!\n", id);
693 return NULL;
696 static int ram_load(QEMUFile *f, void *opaque, int version_id)
698 ram_addr_t addr;
699 int flags, ret = 0;
700 int error;
701 static uint64_t seq_iter;
703 seq_iter++;
705 if (version_id < 4 || version_id > 4) {
706 return -EINVAL;
709 do {
710 addr = qemu_get_be64(f);
712 flags = addr & ~TARGET_PAGE_MASK;
713 addr &= TARGET_PAGE_MASK;
715 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
716 if (version_id == 4) {
717 /* Synchronize RAM block list */
718 char id[256];
719 ram_addr_t length;
720 ram_addr_t total_ram_bytes = addr;
722 while (total_ram_bytes) {
723 RAMBlock *block;
724 uint8_t len;
726 len = qemu_get_byte(f);
727 qemu_get_buffer(f, (uint8_t *)id, len);
728 id[len] = 0;
729 length = qemu_get_be64(f);
731 QLIST_FOREACH(block, &ram_list.blocks, next) {
732 if (!strncmp(id, block->idstr, sizeof(id))) {
733 if (block->length != length) {
734 ret = -EINVAL;
735 goto done;
737 break;
741 if (!block) {
742 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
743 "accept migration\n", id);
744 ret = -EINVAL;
745 goto done;
748 total_ram_bytes -= length;
753 if (flags & RAM_SAVE_FLAG_COMPRESS) {
754 void *host;
755 uint8_t ch;
757 host = host_from_stream_offset(f, addr, flags);
758 if (!host) {
759 return -EINVAL;
762 ch = qemu_get_byte(f);
763 memset(host, ch, TARGET_PAGE_SIZE);
764 #ifndef _WIN32
765 if (ch == 0 &&
766 (!kvm_enabled() || kvm_has_sync_mmu())) {
767 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED);
769 #endif
770 } else if (flags & RAM_SAVE_FLAG_PAGE) {
771 void *host;
773 host = host_from_stream_offset(f, addr, flags);
774 if (!host) {
775 return -EINVAL;
778 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
779 } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
780 if (!migrate_use_xbzrle()) {
781 return -EINVAL;
783 void *host = host_from_stream_offset(f, addr, flags);
784 if (!host) {
785 return -EINVAL;
788 if (load_xbzrle(f, addr, host) < 0) {
789 ret = -EINVAL;
790 goto done;
793 error = qemu_file_get_error(f);
794 if (error) {
795 ret = error;
796 goto done;
798 } while (!(flags & RAM_SAVE_FLAG_EOS));
800 done:
801 DPRINTF("Completed load of VM with exit code %d seq iteration "
802 "%" PRIu64 "\n", ret, seq_iter);
803 return ret;
806 SaveVMHandlers savevm_ram_handlers = {
807 .save_live_setup = ram_save_setup,
808 .save_live_iterate = ram_save_iterate,
809 .save_live_complete = ram_save_complete,
810 .load_state = ram_load,
811 .cancel = ram_migration_cancel,
814 #ifdef HAS_AUDIO
815 struct soundhw {
816 const char *name;
817 const char *descr;
818 int enabled;
819 int isa;
820 union {
821 int (*init_isa) (ISABus *bus);
822 int (*init_pci) (PCIBus *bus);
823 } init;
826 static struct soundhw soundhw[] = {
827 #ifdef HAS_AUDIO_CHOICE
828 #ifdef CONFIG_PCSPK
830 "pcspk",
831 "PC speaker",
834 { .init_isa = pcspk_audio_init }
836 #endif
838 #ifdef CONFIG_SB16
840 "sb16",
841 "Creative Sound Blaster 16",
844 { .init_isa = SB16_init }
846 #endif
848 #ifdef CONFIG_CS4231A
850 "cs4231a",
851 "CS4231A",
854 { .init_isa = cs4231a_init }
856 #endif
858 #ifdef CONFIG_ADLIB
860 "adlib",
861 #ifdef HAS_YMF262
862 "Yamaha YMF262 (OPL3)",
863 #else
864 "Yamaha YM3812 (OPL2)",
865 #endif
868 { .init_isa = Adlib_init }
870 #endif
872 #ifdef CONFIG_GUS
874 "gus",
875 "Gravis Ultrasound GF1",
878 { .init_isa = GUS_init }
880 #endif
882 #ifdef CONFIG_AC97
884 "ac97",
885 "Intel 82801AA AC97 Audio",
888 { .init_pci = ac97_init }
890 #endif
892 #ifdef CONFIG_ES1370
894 "es1370",
895 "ENSONIQ AudioPCI ES1370",
898 { .init_pci = es1370_init }
900 #endif
902 #ifdef CONFIG_HDA
904 "hda",
905 "Intel HD Audio",
908 { .init_pci = intel_hda_and_codec_init }
910 #endif
912 #endif /* HAS_AUDIO_CHOICE */
914 { NULL, NULL, 0, 0, { NULL } }
917 void select_soundhw(const char *optarg)
919 struct soundhw *c;
921 if (is_help_option(optarg)) {
922 show_valid_cards:
924 #ifdef HAS_AUDIO_CHOICE
925 printf("Valid sound card names (comma separated):\n");
926 for (c = soundhw; c->name; ++c) {
927 printf ("%-11s %s\n", c->name, c->descr);
929 printf("\n-soundhw all will enable all of the above\n");
930 #else
931 printf("Machine has no user-selectable audio hardware "
932 "(it may or may not have always-present audio hardware).\n");
933 #endif
934 exit(!is_help_option(optarg));
936 else {
937 size_t l;
938 const char *p;
939 char *e;
940 int bad_card = 0;
942 if (!strcmp(optarg, "all")) {
943 for (c = soundhw; c->name; ++c) {
944 c->enabled = 1;
946 return;
949 p = optarg;
950 while (*p) {
951 e = strchr(p, ',');
952 l = !e ? strlen(p) : (size_t) (e - p);
954 for (c = soundhw; c->name; ++c) {
955 if (!strncmp(c->name, p, l) && !c->name[l]) {
956 c->enabled = 1;
957 break;
961 if (!c->name) {
962 if (l > 80) {
963 fprintf(stderr,
964 "Unknown sound card name (too big to show)\n");
966 else {
967 fprintf(stderr, "Unknown sound card name `%.*s'\n",
968 (int) l, p);
970 bad_card = 1;
972 p += l + (e != NULL);
975 if (bad_card) {
976 goto show_valid_cards;
981 void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
983 struct soundhw *c;
985 for (c = soundhw; c->name; ++c) {
986 if (c->enabled) {
987 if (c->isa) {
988 if (isa_bus) {
989 c->init.init_isa(isa_bus);
991 } else {
992 if (pci_bus) {
993 c->init.init_pci(pci_bus);
999 #else
1000 void select_soundhw(const char *optarg)
1003 void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
1006 #endif
1008 int qemu_uuid_parse(const char *str, uint8_t *uuid)
1010 int ret;
1012 if (strlen(str) != 36) {
1013 return -1;
1016 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1017 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1018 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1019 &uuid[15]);
1021 if (ret != 16) {
1022 return -1;
1024 #ifdef TARGET_I386
1025 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
1026 #endif
1027 return 0;
1030 void do_acpitable_option(const char *optarg)
1032 #ifdef TARGET_I386
1033 if (acpi_table_add(optarg) < 0) {
1034 fprintf(stderr, "Wrong acpi table provided\n");
1035 exit(1);
1037 #endif
1040 void do_smbios_option(const char *optarg)
1042 #ifdef TARGET_I386
1043 if (smbios_entry_add(optarg) < 0) {
1044 fprintf(stderr, "Wrong smbios provided\n");
1045 exit(1);
1047 #endif
1050 void cpudef_init(void)
1052 #if defined(cpudef_setup)
1053 cpudef_setup(); /* parse cpu definitions in target config file */
1054 #endif
1057 int audio_available(void)
1059 #ifdef HAS_AUDIO
1060 return 1;
1061 #else
1062 return 0;
1063 #endif
1066 int tcg_available(void)
1068 return 1;
1071 int kvm_available(void)
1073 #ifdef CONFIG_KVM
1074 return 1;
1075 #else
1076 return 0;
1077 #endif
1080 int xen_available(void)
1082 #ifdef CONFIG_XEN
1083 return 1;
1084 #else
1085 return 0;
1086 #endif
1090 TargetInfo *qmp_query_target(Error **errp)
1092 TargetInfo *info = g_malloc0(sizeof(*info));
1094 info->arch = TARGET_TYPE;
1096 return info;