trap signals for "-serial mon:stdio"
[qemu.git] / arch_init.c
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/monitor.h"
33 #include "sysemu/sysemu.h"
34 #include "qemu/bitops.h"
35 #include "qemu/bitmap.h"
36 #include "sysemu/arch_init.h"
37 #include "audio/audio.h"
38 #include "hw/i386/pc.h"
39 #include "hw/pci/pci.h"
40 #include "hw/audio/audio.h"
41 #include "sysemu/kvm.h"
42 #include "migration/migration.h"
43 #include "hw/i386/smbios.h"
44 #include "exec/address-spaces.h"
45 #include "hw/audio/pcspk.h"
46 #include "migration/page_cache.h"
47 #include "qemu/config-file.h"
48 #include "qmp-commands.h"
49 #include "trace.h"
50 #include "exec/cpu-all.h"
51 #include "hw/acpi/acpi.h"
52
53 #ifdef DEBUG_ARCH_INIT
54 #define DPRINTF(fmt, ...) \
55 do { fprintf(stdout, "arch_init: " fmt, ## __VA_ARGS__); } while (0)
56 #else
57 #define DPRINTF(fmt, ...) \
58 do { } while (0)
59 #endif
60
61 #ifdef TARGET_SPARC
62 int graphic_width = 1024;
63 int graphic_height = 768;
64 int graphic_depth = 8;
65 #else
66 int graphic_width = 800;
67 int graphic_height = 600;
68 int graphic_depth = 32;
69 #endif
70
71
72 #if defined(TARGET_ALPHA)
73 #define QEMU_ARCH QEMU_ARCH_ALPHA
74 #elif defined(TARGET_ARM)
75 #define QEMU_ARCH QEMU_ARCH_ARM
76 #elif defined(TARGET_CRIS)
77 #define QEMU_ARCH QEMU_ARCH_CRIS
78 #elif defined(TARGET_I386)
79 #define QEMU_ARCH QEMU_ARCH_I386
80 #elif defined(TARGET_M68K)
81 #define QEMU_ARCH QEMU_ARCH_M68K
82 #elif defined(TARGET_LM32)
83 #define QEMU_ARCH QEMU_ARCH_LM32
84 #elif defined(TARGET_MICROBLAZE)
85 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE
86 #elif defined(TARGET_MIPS)
87 #define QEMU_ARCH QEMU_ARCH_MIPS
88 #elif defined(TARGET_MOXIE)
89 #define QEMU_ARCH QEMU_ARCH_MOXIE
90 #elif defined(TARGET_OPENRISC)
91 #define QEMU_ARCH QEMU_ARCH_OPENRISC
92 #elif defined(TARGET_PPC)
93 #define QEMU_ARCH QEMU_ARCH_PPC
94 #elif defined(TARGET_S390X)
95 #define QEMU_ARCH QEMU_ARCH_S390X
96 #elif defined(TARGET_SH4)
97 #define QEMU_ARCH QEMU_ARCH_SH4
98 #elif defined(TARGET_SPARC)
99 #define QEMU_ARCH QEMU_ARCH_SPARC
100 #elif defined(TARGET_XTENSA)
101 #define QEMU_ARCH QEMU_ARCH_XTENSA
102 #elif defined(TARGET_UNICORE32)
103 #define QEMU_ARCH QEMU_ARCH_UNICORE32
104 #endif
105
106 const uint32_t arch_type = QEMU_ARCH;
107
108 /***********************************************************/
109 /* ram save/restore */
110
111 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
112 #define RAM_SAVE_FLAG_COMPRESS 0x02
113 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
114 #define RAM_SAVE_FLAG_PAGE 0x08
115 #define RAM_SAVE_FLAG_EOS 0x10
116 #define RAM_SAVE_FLAG_CONTINUE 0x20
117 #define RAM_SAVE_FLAG_XBZRLE 0x40
118
119
120 static struct defconfig_file {
121 const char *filename;
122 /* Indicates it is an user config file (disabled by -no-user-config) */
123 bool userconfig;
124 } default_config_files[] = {
125 { CONFIG_QEMU_CONFDIR "/qemu.conf", true },
126 { CONFIG_QEMU_CONFDIR "/target-" TARGET_NAME ".conf", true },
127 { NULL }, /* end of list */
128 };
129
130
131 int qemu_read_default_config_files(bool userconfig)
132 {
133 int ret;
134 struct defconfig_file *f;
135
136 for (f = default_config_files; f->filename; f++) {
137 if (!userconfig && f->userconfig) {
138 continue;
139 }
140 ret = qemu_read_config_file(f->filename);
141 if (ret < 0 && ret != -ENOENT) {
142 return ret;
143 }
144 }
145
146 return 0;
147 }
148
149 static inline bool is_zero_page(uint8_t *p)
150 {
151 return buffer_find_nonzero_offset(p, TARGET_PAGE_SIZE) ==
152 TARGET_PAGE_SIZE;
153 }
154
155 /* struct contains XBZRLE cache and a static page
156 used by the compression */
157 static struct {
158 /* buffer used for XBZRLE encoding */
159 uint8_t *encoded_buf;
160 /* buffer for storing page content */
161 uint8_t *current_buf;
162 /* buffer used for XBZRLE decoding */
163 uint8_t *decoded_buf;
164 /* Cache for XBZRLE */
165 PageCache *cache;
166 } XBZRLE = {
167 .encoded_buf = NULL,
168 .current_buf = NULL,
169 .decoded_buf = NULL,
170 .cache = NULL,
171 };
172
173
174 int64_t xbzrle_cache_resize(int64_t new_size)
175 {
176 if (XBZRLE.cache != NULL) {
177 return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) *
178 TARGET_PAGE_SIZE;
179 }
180 return pow2floor(new_size);
181 }
182
183 /* accounting for migration statistics */
184 typedef struct AccountingInfo {
185 uint64_t dup_pages;
186 uint64_t skipped_pages;
187 uint64_t norm_pages;
188 uint64_t iterations;
189 uint64_t xbzrle_bytes;
190 uint64_t xbzrle_pages;
191 uint64_t xbzrle_cache_miss;
192 uint64_t xbzrle_overflows;
193 } AccountingInfo;
194
195 static AccountingInfo acct_info;
196
197 static void acct_clear(void)
198 {
199 memset(&acct_info, 0, sizeof(acct_info));
200 }
201
202 uint64_t dup_mig_bytes_transferred(void)
203 {
204 return acct_info.dup_pages * TARGET_PAGE_SIZE;
205 }
206
207 uint64_t dup_mig_pages_transferred(void)
208 {
209 return acct_info.dup_pages;
210 }
211
212 uint64_t skipped_mig_bytes_transferred(void)
213 {
214 return acct_info.skipped_pages * TARGET_PAGE_SIZE;
215 }
216
217 uint64_t skipped_mig_pages_transferred(void)
218 {
219 return acct_info.skipped_pages;
220 }
221
222 uint64_t norm_mig_bytes_transferred(void)
223 {
224 return acct_info.norm_pages * TARGET_PAGE_SIZE;
225 }
226
227 uint64_t norm_mig_pages_transferred(void)
228 {
229 return acct_info.norm_pages;
230 }
231
232 uint64_t xbzrle_mig_bytes_transferred(void)
233 {
234 return acct_info.xbzrle_bytes;
235 }
236
237 uint64_t xbzrle_mig_pages_transferred(void)
238 {
239 return acct_info.xbzrle_pages;
240 }
241
242 uint64_t xbzrle_mig_pages_cache_miss(void)
243 {
244 return acct_info.xbzrle_cache_miss;
245 }
246
247 uint64_t xbzrle_mig_pages_overflow(void)
248 {
249 return acct_info.xbzrle_overflows;
250 }
251
252 static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
253 int cont, int flag)
254 {
255 size_t size;
256
257 qemu_put_be64(f, offset | cont | flag);
258 size = 8;
259
260 if (!cont) {
261 qemu_put_byte(f, strlen(block->idstr));
262 qemu_put_buffer(f, (uint8_t *)block->idstr,
263 strlen(block->idstr));
264 size += 1 + strlen(block->idstr);
265 }
266 return size;
267 }
268
269 #define ENCODING_FLAG_XBZRLE 0x1
270
271 static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
272 ram_addr_t current_addr, RAMBlock *block,
273 ram_addr_t offset, int cont, bool last_stage)
274 {
275 int encoded_len = 0, bytes_sent = -1;
276 uint8_t *prev_cached_page;
277
278 if (!cache_is_cached(XBZRLE.cache, current_addr)) {
279 if (!last_stage) {
280 cache_insert(XBZRLE.cache, current_addr, current_data);
281 }
282 acct_info.xbzrle_cache_miss++;
283 return -1;
284 }
285
286 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
287
288 /* save current buffer into memory */
289 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE);
290
291 /* XBZRLE encoding (if there is no overflow) */
292 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
293 TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
294 TARGET_PAGE_SIZE);
295 if (encoded_len == 0) {
296 DPRINTF("Skipping unmodified page\n");
297 return 0;
298 } else if (encoded_len == -1) {
299 DPRINTF("Overflow\n");
300 acct_info.xbzrle_overflows++;
301 /* update data in the cache */
302 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE);
303 return -1;
304 }
305
306 /* we need to update the data in the cache, in order to get the same data */
307 if (!last_stage) {
308 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
309 }
310
311 /* Send XBZRLE based compressed page */
312 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
313 qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
314 qemu_put_be16(f, encoded_len);
315 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
316 bytes_sent += encoded_len + 1 + 2;
317 acct_info.xbzrle_pages++;
318 acct_info.xbzrle_bytes += bytes_sent;
319
320 return bytes_sent;
321 }
322
323
324 /* This is the last block that we have visited serching for dirty pages
325 */
326 static RAMBlock *last_seen_block;
327 /* This is the last block from where we have sent data */
328 static RAMBlock *last_sent_block;
329 static ram_addr_t last_offset;
330 static unsigned long *migration_bitmap;
331 static uint64_t migration_dirty_pages;
332 static uint32_t last_version;
333 static bool ram_bulk_stage;
334
335 static inline
336 ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
337 ram_addr_t start)
338 {
339 unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS;
340 unsigned long nr = base + (start >> TARGET_PAGE_BITS);
341 unsigned long size = base + (int128_get64(mr->size) >> TARGET_PAGE_BITS);
342
343 unsigned long next;
344
345 if (ram_bulk_stage && nr > base) {
346 next = nr + 1;
347 } else {
348 next = find_next_bit(migration_bitmap, size, nr);
349 }
350
351 if (next < size) {
352 clear_bit(next, migration_bitmap);
353 migration_dirty_pages--;
354 }
355 return (next - base) << TARGET_PAGE_BITS;
356 }
357
358 static inline bool migration_bitmap_set_dirty(MemoryRegion *mr,
359 ram_addr_t offset)
360 {
361 bool ret;
362 int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS;
363
364 ret = test_and_set_bit(nr, migration_bitmap);
365
366 if (!ret) {
367 migration_dirty_pages++;
368 }
369 return ret;
370 }
371
372 /* Needs iothread lock! */
373
374 static void migration_bitmap_sync(void)
375 {
376 RAMBlock *block;
377 ram_addr_t addr;
378 uint64_t num_dirty_pages_init = migration_dirty_pages;
379 MigrationState *s = migrate_get_current();
380 static int64_t start_time;
381 static int64_t num_dirty_pages_period;
382 int64_t end_time;
383
384 if (!start_time) {
385 start_time = qemu_get_clock_ms(rt_clock);
386 }
387
388 trace_migration_bitmap_sync_start();
389 address_space_sync_dirty_bitmap(&address_space_memory);
390
391 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
392 for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) {
393 if (memory_region_test_and_clear_dirty(block->mr,
394 addr, TARGET_PAGE_SIZE,
395 DIRTY_MEMORY_MIGRATION)) {
396 migration_bitmap_set_dirty(block->mr, addr);
397 }
398 }
399 }
400 trace_migration_bitmap_sync_end(migration_dirty_pages
401 - num_dirty_pages_init);
402 num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
403 end_time = qemu_get_clock_ms(rt_clock);
404
405 /* more than 1 second = 1000 millisecons */
406 if (end_time > start_time + 1000) {
407 s->dirty_pages_rate = num_dirty_pages_period * 1000
408 / (end_time - start_time);
409 s->dirty_bytes_rate = s->dirty_pages_rate * TARGET_PAGE_SIZE;
410 start_time = end_time;
411 num_dirty_pages_period = 0;
412 }
413 }
414
415 /*
416 * ram_save_block: Writes a page of memory to the stream f
417 *
418 * Returns: The number of bytes written.
419 * 0 means no dirty pages
420 */
421
422 static int ram_save_block(QEMUFile *f, bool last_stage)
423 {
424 RAMBlock *block = last_seen_block;
425 ram_addr_t offset = last_offset;
426 bool complete_round = false;
427 int bytes_sent = 0;
428 MemoryRegion *mr;
429 ram_addr_t current_addr;
430
431 if (!block)
432 block = QTAILQ_FIRST(&ram_list.blocks);
433
434 while (true) {
435 mr = block->mr;
436 offset = migration_bitmap_find_and_reset_dirty(mr, offset);
437 if (complete_round && block == last_seen_block &&
438 offset >= last_offset) {
439 break;
440 }
441 if (offset >= block->length) {
442 offset = 0;
443 block = QTAILQ_NEXT(block, next);
444 if (!block) {
445 block = QTAILQ_FIRST(&ram_list.blocks);
446 complete_round = true;
447 ram_bulk_stage = false;
448 }
449 } else {
450 uint8_t *p;
451 int cont = (block == last_sent_block) ?
452 RAM_SAVE_FLAG_CONTINUE : 0;
453
454 p = memory_region_get_ram_ptr(mr) + offset;
455
456 /* In doubt sent page as normal */
457 bytes_sent = -1;
458 if (is_zero_page(p)) {
459 acct_info.dup_pages++;
460 bytes_sent = save_block_hdr(f, block, offset, cont,
461 RAM_SAVE_FLAG_COMPRESS);
462 qemu_put_byte(f, 0);
463 bytes_sent++;
464 } else if (!ram_bulk_stage && migrate_use_xbzrle()) {
465 current_addr = block->offset + offset;
466 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
467 offset, cont, last_stage);
468 if (!last_stage) {
469 p = get_cached_data(XBZRLE.cache, current_addr);
470 }
471 }
472
473 /* XBZRLE overflow or normal page */
474 if (bytes_sent == -1) {
475 bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
476 qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE);
477 bytes_sent += TARGET_PAGE_SIZE;
478 acct_info.norm_pages++;
479 }
480
481 /* if page is unmodified, continue to the next */
482 if (bytes_sent > 0) {
483 last_sent_block = block;
484 break;
485 }
486 }
487 }
488 last_seen_block = block;
489 last_offset = offset;
490
491 return bytes_sent;
492 }
493
494 static uint64_t bytes_transferred;
495
496 void acct_update_position(QEMUFile *f, size_t size, bool zero)
497 {
498 uint64_t pages = size / TARGET_PAGE_SIZE;
499 if (zero) {
500 acct_info.dup_pages += pages;
501 } else {
502 acct_info.norm_pages += pages;
503 bytes_transferred += size;
504 qemu_update_position(f, size);
505 }
506 }
507
508 static ram_addr_t ram_save_remaining(void)
509 {
510 return migration_dirty_pages;
511 }
512
513 uint64_t ram_bytes_remaining(void)
514 {
515 return ram_save_remaining() * TARGET_PAGE_SIZE;
516 }
517
518 uint64_t ram_bytes_transferred(void)
519 {
520 return bytes_transferred;
521 }
522
523 uint64_t ram_bytes_total(void)
524 {
525 RAMBlock *block;
526 uint64_t total = 0;
527
528 QTAILQ_FOREACH(block, &ram_list.blocks, next)
529 total += block->length;
530
531 return total;
532 }
533
534 static void migration_end(void)
535 {
536 if (migration_bitmap) {
537 memory_global_dirty_log_stop();
538 g_free(migration_bitmap);
539 migration_bitmap = NULL;
540 }
541
542 if (XBZRLE.cache) {
543 cache_fini(XBZRLE.cache);
544 g_free(XBZRLE.cache);
545 g_free(XBZRLE.encoded_buf);
546 g_free(XBZRLE.current_buf);
547 g_free(XBZRLE.decoded_buf);
548 XBZRLE.cache = NULL;
549 }
550 }
551
552 static void ram_migration_cancel(void *opaque)
553 {
554 migration_end();
555 }
556
557 static void reset_ram_globals(void)
558 {
559 last_seen_block = NULL;
560 last_sent_block = NULL;
561 last_offset = 0;
562 last_version = ram_list.version;
563 ram_bulk_stage = true;
564 }
565
566 #define MAX_WAIT 50 /* ms, half buffered_file limit */
567
568 static int ram_save_setup(QEMUFile *f, void *opaque)
569 {
570 RAMBlock *block;
571 int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
572
573 migration_bitmap = bitmap_new(ram_pages);
574 bitmap_set(migration_bitmap, 0, ram_pages);
575 migration_dirty_pages = ram_pages;
576
577 if (migrate_use_xbzrle()) {
578 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
579 TARGET_PAGE_SIZE,
580 TARGET_PAGE_SIZE);
581 if (!XBZRLE.cache) {
582 DPRINTF("Error creating cache\n");
583 return -1;
584 }
585 XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE);
586 XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE);
587 acct_clear();
588 }
589
590 qemu_mutex_lock_iothread();
591 qemu_mutex_lock_ramlist();
592 bytes_transferred = 0;
593 reset_ram_globals();
594
595 memory_global_dirty_log_start();
596 migration_bitmap_sync();
597 qemu_mutex_unlock_iothread();
598
599 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
600
601 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
602 qemu_put_byte(f, strlen(block->idstr));
603 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
604 qemu_put_be64(f, block->length);
605 }
606
607 qemu_mutex_unlock_ramlist();
608 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
609
610 return 0;
611 }
612
613 static int ram_save_iterate(QEMUFile *f, void *opaque)
614 {
615 int ret;
616 int i;
617 int64_t t0;
618 int total_sent = 0;
619
620 qemu_mutex_lock_ramlist();
621
622 if (ram_list.version != last_version) {
623 reset_ram_globals();
624 }
625
626 t0 = qemu_get_clock_ns(rt_clock);
627 i = 0;
628 while ((ret = qemu_file_rate_limit(f)) == 0) {
629 int bytes_sent;
630
631 bytes_sent = ram_save_block(f, false);
632 /* no more blocks to sent */
633 if (bytes_sent == 0) {
634 break;
635 }
636 total_sent += bytes_sent;
637 acct_info.iterations++;
638 /* we want to check in the 1st loop, just in case it was the 1st time
639 and we had to sync the dirty bitmap.
640 qemu_get_clock_ns() is a bit expensive, so we only check each some
641 iterations
642 */
643 if ((i & 63) == 0) {
644 uint64_t t1 = (qemu_get_clock_ns(rt_clock) - t0) / 1000000;
645 if (t1 > MAX_WAIT) {
646 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
647 t1, i);
648 break;
649 }
650 }
651 i++;
652 }
653
654 qemu_mutex_unlock_ramlist();
655
656 if (ret < 0) {
657 bytes_transferred += total_sent;
658 return ret;
659 }
660
661 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
662 total_sent += 8;
663 bytes_transferred += total_sent;
664
665 return total_sent;
666 }
667
668 static int ram_save_complete(QEMUFile *f, void *opaque)
669 {
670 qemu_mutex_lock_ramlist();
671 migration_bitmap_sync();
672
673 /* try transferring iterative blocks of memory */
674
675 /* flush all remaining blocks regardless of rate limiting */
676 while (true) {
677 int bytes_sent;
678
679 bytes_sent = ram_save_block(f, true);
680 /* no more blocks to sent */
681 if (bytes_sent == 0) {
682 break;
683 }
684 bytes_transferred += bytes_sent;
685 }
686 migration_end();
687
688 qemu_mutex_unlock_ramlist();
689 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
690
691 return 0;
692 }
693
694 static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size)
695 {
696 uint64_t remaining_size;
697
698 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
699
700 if (remaining_size < max_size) {
701 qemu_mutex_lock_iothread();
702 migration_bitmap_sync();
703 qemu_mutex_unlock_iothread();
704 remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
705 }
706 return remaining_size;
707 }
708
709 static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
710 {
711 int ret, rc = 0;
712 unsigned int xh_len;
713 int xh_flags;
714
715 if (!XBZRLE.decoded_buf) {
716 XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE);
717 }
718
719 /* extract RLE header */
720 xh_flags = qemu_get_byte(f);
721 xh_len = qemu_get_be16(f);
722
723 if (xh_flags != ENCODING_FLAG_XBZRLE) {
724 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
725 return -1;
726 }
727
728 if (xh_len > TARGET_PAGE_SIZE) {
729 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
730 return -1;
731 }
732 /* load data and decode */
733 qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len);
734
735 /* decode RLE */
736 ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host,
737 TARGET_PAGE_SIZE);
738 if (ret == -1) {
739 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
740 rc = -1;
741 } else if (ret > TARGET_PAGE_SIZE) {
742 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
743 ret, TARGET_PAGE_SIZE);
744 abort();
745 }
746
747 return rc;
748 }
749
750 static inline void *host_from_stream_offset(QEMUFile *f,
751 ram_addr_t offset,
752 int flags)
753 {
754 static RAMBlock *block = NULL;
755 char id[256];
756 uint8_t len;
757
758 if (flags & RAM_SAVE_FLAG_CONTINUE) {
759 if (!block) {
760 fprintf(stderr, "Ack, bad migration stream!\n");
761 return NULL;
762 }
763
764 return memory_region_get_ram_ptr(block->mr) + offset;
765 }
766
767 len = qemu_get_byte(f);
768 qemu_get_buffer(f, (uint8_t *)id, len);
769 id[len] = 0;
770
771 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
772 if (!strncmp(id, block->idstr, sizeof(id)))
773 return memory_region_get_ram_ptr(block->mr) + offset;
774 }
775
776 fprintf(stderr, "Can't find block %s!\n", id);
777 return NULL;
778 }
779
780 static int ram_load(QEMUFile *f, void *opaque, int version_id)
781 {
782 ram_addr_t addr;
783 int flags, ret = 0;
784 int error;
785 static uint64_t seq_iter;
786
787 seq_iter++;
788
789 if (version_id < 4 || version_id > 4) {
790 return -EINVAL;
791 }
792
793 do {
794 addr = qemu_get_be64(f);
795
796 flags = addr & ~TARGET_PAGE_MASK;
797 addr &= TARGET_PAGE_MASK;
798
799 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
800 if (version_id == 4) {
801 /* Synchronize RAM block list */
802 char id[256];
803 ram_addr_t length;
804 ram_addr_t total_ram_bytes = addr;
805
806 while (total_ram_bytes) {
807 RAMBlock *block;
808 uint8_t len;
809
810 len = qemu_get_byte(f);
811 qemu_get_buffer(f, (uint8_t *)id, len);
812 id[len] = 0;
813 length = qemu_get_be64(f);
814
815 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
816 if (!strncmp(id, block->idstr, sizeof(id))) {
817 if (block->length != length) {
818 fprintf(stderr,
819 "Length mismatch: %s: " RAM_ADDR_FMT
820 " in != " RAM_ADDR_FMT "\n", id, length,
821 block->length);
822 ret = -EINVAL;
823 goto done;
824 }
825 break;
826 }
827 }
828
829 if (!block) {
830 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
831 "accept migration\n", id);
832 ret = -EINVAL;
833 goto done;
834 }
835
836 total_ram_bytes -= length;
837 }
838 }
839 }
840
841 if (flags & RAM_SAVE_FLAG_COMPRESS) {
842 void *host;
843 uint8_t ch;
844
845 host = host_from_stream_offset(f, addr, flags);
846 if (!host) {
847 return -EINVAL;
848 }
849
850 ch = qemu_get_byte(f);
851 if (ch != 0 || !is_zero_page(host)) {
852 memset(host, ch, TARGET_PAGE_SIZE);
853 #ifndef _WIN32
854 if (ch == 0 &&
855 (!kvm_enabled() || kvm_has_sync_mmu()) &&
856 getpagesize() <= TARGET_PAGE_SIZE) {
857 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED);
858 }
859 #endif
860 }
861 } else if (flags & RAM_SAVE_FLAG_PAGE) {
862 void *host;
863
864 host = host_from_stream_offset(f, addr, flags);
865 if (!host) {
866 return -EINVAL;
867 }
868
869 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
870 } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
871 void *host = host_from_stream_offset(f, addr, flags);
872 if (!host) {
873 return -EINVAL;
874 }
875
876 if (load_xbzrle(f, addr, host) < 0) {
877 ret = -EINVAL;
878 goto done;
879 }
880 }
881 error = qemu_file_get_error(f);
882 if (error) {
883 ret = error;
884 goto done;
885 }
886 } while (!(flags & RAM_SAVE_FLAG_EOS));
887
888 done:
889 DPRINTF("Completed load of VM with exit code %d seq iteration "
890 "%" PRIu64 "\n", ret, seq_iter);
891 return ret;
892 }
893
894 SaveVMHandlers savevm_ram_handlers = {
895 .save_live_setup = ram_save_setup,
896 .save_live_iterate = ram_save_iterate,
897 .save_live_complete = ram_save_complete,
898 .save_live_pending = ram_save_pending,
899 .load_state = ram_load,
900 .cancel = ram_migration_cancel,
901 };
902
903 struct soundhw {
904 const char *name;
905 const char *descr;
906 int enabled;
907 int isa;
908 union {
909 int (*init_isa) (ISABus *bus);
910 int (*init_pci) (PCIBus *bus);
911 } init;
912 };
913
914 static struct soundhw soundhw[9];
915 static int soundhw_count;
916
917 void isa_register_soundhw(const char *name, const char *descr,
918 int (*init_isa)(ISABus *bus))
919 {
920 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
921 soundhw[soundhw_count].name = name;
922 soundhw[soundhw_count].descr = descr;
923 soundhw[soundhw_count].isa = 1;
924 soundhw[soundhw_count].init.init_isa = init_isa;
925 soundhw_count++;
926 }
927
928 void pci_register_soundhw(const char *name, const char *descr,
929 int (*init_pci)(PCIBus *bus))
930 {
931 assert(soundhw_count < ARRAY_SIZE(soundhw) - 1);
932 soundhw[soundhw_count].name = name;
933 soundhw[soundhw_count].descr = descr;
934 soundhw[soundhw_count].isa = 0;
935 soundhw[soundhw_count].init.init_pci = init_pci;
936 soundhw_count++;
937 }
938
939 void select_soundhw(const char *optarg)
940 {
941 struct soundhw *c;
942
943 if (is_help_option(optarg)) {
944 show_valid_cards:
945
946 if (soundhw_count) {
947 printf("Valid sound card names (comma separated):\n");
948 for (c = soundhw; c->name; ++c) {
949 printf ("%-11s %s\n", c->name, c->descr);
950 }
951 printf("\n-soundhw all will enable all of the above\n");
952 } else {
953 printf("Machine has no user-selectable audio hardware "
954 "(it may or may not have always-present audio hardware).\n");
955 }
956 exit(!is_help_option(optarg));
957 }
958 else {
959 size_t l;
960 const char *p;
961 char *e;
962 int bad_card = 0;
963
964 if (!strcmp(optarg, "all")) {
965 for (c = soundhw; c->name; ++c) {
966 c->enabled = 1;
967 }
968 return;
969 }
970
971 p = optarg;
972 while (*p) {
973 e = strchr(p, ',');
974 l = !e ? strlen(p) : (size_t) (e - p);
975
976 for (c = soundhw; c->name; ++c) {
977 if (!strncmp(c->name, p, l) && !c->name[l]) {
978 c->enabled = 1;
979 break;
980 }
981 }
982
983 if (!c->name) {
984 if (l > 80) {
985 fprintf(stderr,
986 "Unknown sound card name (too big to show)\n");
987 }
988 else {
989 fprintf(stderr, "Unknown sound card name `%.*s'\n",
990 (int) l, p);
991 }
992 bad_card = 1;
993 }
994 p += l + (e != NULL);
995 }
996
997 if (bad_card) {
998 goto show_valid_cards;
999 }
1000 }
1001 }
1002
1003 void audio_init(void)
1004 {
1005 struct soundhw *c;
1006 ISABus *isa_bus = (ISABus *) object_resolve_path_type("", TYPE_ISA_BUS, NULL);
1007 PCIBus *pci_bus = (PCIBus *) object_resolve_path_type("", TYPE_PCI_BUS, NULL);
1008
1009 for (c = soundhw; c->name; ++c) {
1010 if (c->enabled) {
1011 if (c->isa) {
1012 if (!isa_bus) {
1013 fprintf(stderr, "ISA bus not available for %s\n", c->name);
1014 exit(1);
1015 }
1016 c->init.init_isa(isa_bus);
1017 } else {
1018 if (!pci_bus) {
1019 fprintf(stderr, "PCI bus not available for %s\n", c->name);
1020 exit(1);
1021 }
1022 c->init.init_pci(pci_bus);
1023 }
1024 }
1025 }
1026 }
1027
1028 int qemu_uuid_parse(const char *str, uint8_t *uuid)
1029 {
1030 int ret;
1031
1032 if (strlen(str) != 36) {
1033 return -1;
1034 }
1035
1036 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1037 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1038 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1039 &uuid[15]);
1040
1041 if (ret != 16) {
1042 return -1;
1043 }
1044 #ifdef TARGET_I386
1045 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), uuid, 16);
1046 #endif
1047 return 0;
1048 }
1049
1050 void do_acpitable_option(const QemuOpts *opts)
1051 {
1052 #ifdef TARGET_I386
1053 Error *err = NULL;
1054
1055 acpi_table_add(opts, &err);
1056 if (err) {
1057 fprintf(stderr, "Wrong acpi table provided: %s\n",
1058 error_get_pretty(err));
1059 error_free(err);
1060 exit(1);
1061 }
1062 #endif
1063 }
1064
1065 void do_smbios_option(const char *optarg)
1066 {
1067 #ifdef TARGET_I386
1068 if (smbios_entry_add(optarg) < 0) {
1069 exit(1);
1070 }
1071 #endif
1072 }
1073
1074 void cpudef_init(void)
1075 {
1076 #if defined(cpudef_setup)
1077 cpudef_setup(); /* parse cpu definitions in target config file */
1078 #endif
1079 }
1080
1081 int tcg_available(void)
1082 {
1083 return 1;
1084 }
1085
1086 int kvm_available(void)
1087 {
1088 #ifdef CONFIG_KVM
1089 return 1;
1090 #else
1091 return 0;
1092 #endif
1093 }
1094
1095 int xen_available(void)
1096 {
1097 #ifdef CONFIG_XEN
1098 return 1;
1099 #else
1100 return 0;
1101 #endif
1102 }
1103
1104
1105 TargetInfo *qmp_query_target(Error **errp)
1106 {
1107 TargetInfo *info = g_malloc0(sizeof(*info));
1108
1109 info->arch = g_strdup(TARGET_NAME);
1110
1111 return info;
1112 }