blob: 6695ccfdc5cbf5320ed240fd160fadc73afbb9dc [file] [log] [blame]
Blue Swirlad960902010-03-29 19:23:52 +00001/*
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>
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +020026#include <stdlib.h>
Blue Swirlad960902010-03-29 19:23:52 +000027#ifndef _WIN32
Blue Swirl1c47cb12010-03-30 19:27:34 +000028#include <sys/types.h>
Blue Swirlad960902010-03-29 19:23:52 +000029#include <sys/mman.h>
30#endif
31#include "config.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010032#include "monitor/monitor.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010033#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010034#include "qemu/bitops.h"
35#include "qemu/bitmap.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010036#include "sysemu/arch_init.h"
Blue Swirlad960902010-03-29 19:23:52 +000037#include "audio/audio.h"
38#include "hw/pc.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020039#include "hw/pci/pci.h"
Blue Swirlad960902010-03-29 19:23:52 +000040#include "hw/audiodev.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010041#include "sysemu/kvm.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010042#include "migration/migration.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010043#include "exec/gdbstub.h"
Blue Swirlad960902010-03-29 19:23:52 +000044#include "hw/smbios.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010045#include "exec/address-spaces.h"
Jan Kiszka302fe512012-02-17 11:24:34 +010046#include "hw/pcspk.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010047#include "migration/page_cache.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010048#include "qemu/config-file.h"
Daniel P. Berrange99afc912012-08-20 15:31:38 +010049#include "qmp-commands.h"
Juan Quintela3c121932012-09-04 13:08:57 +020050#include "trace.h"
Paolo Bonzini0d6d3c82012-11-14 15:45:02 +010051#include "exec/cpu-all.h"
Blue Swirlad960902010-03-29 19:23:52 +000052
Orit Wasserman3a697f62012-06-19 18:43:15 +030053#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
Blue Swirlad960902010-03-29 19:23:52 +000061#ifdef TARGET_SPARC
62int graphic_width = 1024;
63int graphic_height = 768;
64int graphic_depth = 8;
65#else
66int graphic_width = 800;
67int graphic_height = 600;
68int graphic_depth = 15;
69#endif
70
Blue Swirlad960902010-03-29 19:23:52 +000071
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
Michael Walle81ea0e12011-02-17 23:45:02 +010082#elif defined(TARGET_LM32)
83#define QEMU_ARCH QEMU_ARCH_LM32
Blue Swirlad960902010-03-29 19:23:52 +000084#elif defined(TARGET_MICROBLAZE)
85#define QEMU_ARCH QEMU_ARCH_MICROBLAZE
86#elif defined(TARGET_MIPS)
87#define QEMU_ARCH QEMU_ARCH_MIPS
Jia Liue67db062012-07-20 15:50:39 +080088#elif defined(TARGET_OPENRISC)
89#define QEMU_ARCH QEMU_ARCH_OPENRISC
Blue Swirlad960902010-03-29 19:23:52 +000090#elif defined(TARGET_PPC)
91#define QEMU_ARCH QEMU_ARCH_PPC
92#elif defined(TARGET_S390X)
93#define QEMU_ARCH QEMU_ARCH_S390X
94#elif defined(TARGET_SH4)
95#define QEMU_ARCH QEMU_ARCH_SH4
96#elif defined(TARGET_SPARC)
97#define QEMU_ARCH QEMU_ARCH_SPARC
Max Filippov23288262011-09-06 03:55:25 +040098#elif defined(TARGET_XTENSA)
99#define QEMU_ARCH QEMU_ARCH_XTENSA
Guan Xuetao4f23a1e2012-08-10 14:42:21 +0800100#elif defined(TARGET_UNICORE32)
101#define QEMU_ARCH QEMU_ARCH_UNICORE32
Blue Swirlad960902010-03-29 19:23:52 +0000102#endif
103
104const uint32_t arch_type = QEMU_ARCH;
105
106/***********************************************************/
107/* ram save/restore */
108
Yoshiaki Tamurad20878d2010-08-18 13:30:12 +0900109#define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
110#define RAM_SAVE_FLAG_COMPRESS 0x02
111#define RAM_SAVE_FLAG_MEM_SIZE 0x04
112#define RAM_SAVE_FLAG_PAGE 0x08
113#define RAM_SAVE_FLAG_EOS 0x10
114#define RAM_SAVE_FLAG_CONTINUE 0x20
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300115#define RAM_SAVE_FLAG_XBZRLE 0x40
Blue Swirlad960902010-03-29 19:23:52 +0000116
Paolo Bonzini86003612011-12-23 16:17:26 +0100117#ifdef __ALTIVEC__
118#include <altivec.h>
119#define VECTYPE vector unsigned char
120#define SPLAT(p) vec_splat(vec_ld(0, p), 0)
121#define ALL_EQ(v1, v2) vec_all_eq(v1, v2)
Andreas Färberf283edc2012-05-27 16:21:02 +0200122/* altivec.h may redefine the bool macro as vector type.
123 * Reset it to POSIX semantics. */
124#undef bool
125#define bool _Bool
Paolo Bonzini86003612011-12-23 16:17:26 +0100126#elif defined __SSE2__
127#include <emmintrin.h>
128#define VECTYPE __m128i
129#define SPLAT(p) _mm_set1_epi8(*(p))
130#define ALL_EQ(v1, v2) (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) == 0xFFFF)
131#else
132#define VECTYPE unsigned long
133#define SPLAT(p) (*(p) * (~0UL / 255))
134#define ALL_EQ(v1, v2) ((v1) == (v2))
135#endif
136
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300137
Eduardo Habkost756557d2012-05-02 13:07:27 -0300138static struct defconfig_file {
139 const char *filename;
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300140 /* Indicates it is an user config file (disabled by -no-user-config) */
141 bool userconfig;
Eduardo Habkost756557d2012-05-02 13:07:27 -0300142} default_config_files[] = {
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300143 { CONFIG_QEMU_CONFDIR "/qemu.conf", true },
144 { CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", true },
Eduardo Habkost756557d2012-05-02 13:07:27 -0300145 { NULL }, /* end of list */
146};
147
148
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300149int qemu_read_default_config_files(bool userconfig)
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300150{
151 int ret;
Eduardo Habkost756557d2012-05-02 13:07:27 -0300152 struct defconfig_file *f;
153
154 for (f = default_config_files; f->filename; f++) {
Eduardo Habkostf29a5612012-05-02 13:07:29 -0300155 if (!userconfig && f->userconfig) {
156 continue;
157 }
Eduardo Habkost756557d2012-05-02 13:07:27 -0300158 ret = qemu_read_config_file(f->filename);
159 if (ret < 0 && ret != -ENOENT) {
160 return ret;
161 }
162 }
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300163
Eduardo Habkostb5a8fe52012-05-02 13:07:25 -0300164 return 0;
165}
166
Paolo Bonzini86003612011-12-23 16:17:26 +0100167static int is_dup_page(uint8_t *page)
Blue Swirlad960902010-03-29 19:23:52 +0000168{
Paolo Bonzini86003612011-12-23 16:17:26 +0100169 VECTYPE *p = (VECTYPE *)page;
170 VECTYPE val = SPLAT(page);
Blue Swirlad960902010-03-29 19:23:52 +0000171 int i;
172
Paolo Bonzini86003612011-12-23 16:17:26 +0100173 for (i = 0; i < TARGET_PAGE_SIZE / sizeof(VECTYPE); i++) {
174 if (!ALL_EQ(val, p[i])) {
Blue Swirlad960902010-03-29 19:23:52 +0000175 return 0;
176 }
177 }
178
179 return 1;
180}
181
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300182/* struct contains XBZRLE cache and a static page
183 used by the compression */
184static struct {
185 /* buffer used for XBZRLE encoding */
186 uint8_t *encoded_buf;
187 /* buffer for storing page content */
188 uint8_t *current_buf;
189 /* buffer used for XBZRLE decoding */
190 uint8_t *decoded_buf;
191 /* Cache for XBZRLE */
192 PageCache *cache;
193} XBZRLE = {
194 .encoded_buf = NULL,
195 .current_buf = NULL,
196 .decoded_buf = NULL,
197 .cache = NULL,
198};
199
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300200
201int64_t xbzrle_cache_resize(int64_t new_size)
202{
203 if (XBZRLE.cache != NULL) {
204 return cache_resize(XBZRLE.cache, new_size / TARGET_PAGE_SIZE) *
205 TARGET_PAGE_SIZE;
206 }
207 return pow2floor(new_size);
208}
209
Orit Wasserman004d4c12012-08-06 21:42:56 +0300210/* accounting for migration statistics */
211typedef struct AccountingInfo {
212 uint64_t dup_pages;
213 uint64_t norm_pages;
214 uint64_t iterations;
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300215 uint64_t xbzrle_bytes;
216 uint64_t xbzrle_pages;
217 uint64_t xbzrle_cache_miss;
218 uint64_t xbzrle_overflows;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300219} AccountingInfo;
220
221static AccountingInfo acct_info;
222
223static void acct_clear(void)
224{
225 memset(&acct_info, 0, sizeof(acct_info));
226}
227
228uint64_t dup_mig_bytes_transferred(void)
229{
230 return acct_info.dup_pages * TARGET_PAGE_SIZE;
231}
232
233uint64_t dup_mig_pages_transferred(void)
234{
235 return acct_info.dup_pages;
236}
237
238uint64_t norm_mig_bytes_transferred(void)
239{
240 return acct_info.norm_pages * TARGET_PAGE_SIZE;
241}
242
243uint64_t norm_mig_pages_transferred(void)
244{
245 return acct_info.norm_pages;
246}
247
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300248uint64_t xbzrle_mig_bytes_transferred(void)
249{
250 return acct_info.xbzrle_bytes;
251}
252
253uint64_t xbzrle_mig_pages_transferred(void)
254{
255 return acct_info.xbzrle_pages;
256}
257
258uint64_t xbzrle_mig_pages_cache_miss(void)
259{
260 return acct_info.xbzrle_cache_miss;
261}
262
263uint64_t xbzrle_mig_pages_overflow(void)
264{
265 return acct_info.xbzrle_overflows;
266}
267
Orit Wasserman0c51f432012-06-19 18:43:14 +0300268static void save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
269 int cont, int flag)
270{
271 qemu_put_be64(f, offset | cont | flag);
272 if (!cont) {
273 qemu_put_byte(f, strlen(block->idstr));
274 qemu_put_buffer(f, (uint8_t *)block->idstr,
275 strlen(block->idstr));
276 }
277
278}
279
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300280#define ENCODING_FLAG_XBZRLE 0x1
281
282static int save_xbzrle_page(QEMUFile *f, uint8_t *current_data,
283 ram_addr_t current_addr, RAMBlock *block,
Juan Quinteladd051c72012-08-06 21:42:58 +0300284 ram_addr_t offset, int cont, bool last_stage)
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300285{
286 int encoded_len = 0, bytes_sent = -1;
287 uint8_t *prev_cached_page;
288
289 if (!cache_is_cached(XBZRLE.cache, current_addr)) {
Juan Quinteladd051c72012-08-06 21:42:58 +0300290 if (!last_stage) {
291 cache_insert(XBZRLE.cache, current_addr,
292 g_memdup(current_data, TARGET_PAGE_SIZE));
293 }
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300294 acct_info.xbzrle_cache_miss++;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300295 return -1;
296 }
297
298 prev_cached_page = get_cached_data(XBZRLE.cache, current_addr);
299
300 /* save current buffer into memory */
301 memcpy(XBZRLE.current_buf, current_data, TARGET_PAGE_SIZE);
302
303 /* XBZRLE encoding (if there is no overflow) */
304 encoded_len = xbzrle_encode_buffer(prev_cached_page, XBZRLE.current_buf,
305 TARGET_PAGE_SIZE, XBZRLE.encoded_buf,
306 TARGET_PAGE_SIZE);
307 if (encoded_len == 0) {
308 DPRINTF("Skipping unmodified page\n");
309 return 0;
310 } else if (encoded_len == -1) {
311 DPRINTF("Overflow\n");
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300312 acct_info.xbzrle_overflows++;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300313 /* update data in the cache */
314 memcpy(prev_cached_page, current_data, TARGET_PAGE_SIZE);
315 return -1;
316 }
317
318 /* we need to update the data in the cache, in order to get the same data */
Juan Quinteladd051c72012-08-06 21:42:58 +0300319 if (!last_stage) {
320 memcpy(prev_cached_page, XBZRLE.current_buf, TARGET_PAGE_SIZE);
321 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300322
323 /* Send XBZRLE based compressed page */
324 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
325 qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
326 qemu_put_be16(f, encoded_len);
327 qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
328 bytes_sent = encoded_len + 1 + 2;
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300329 acct_info.xbzrle_pages++;
330 acct_info.xbzrle_bytes += bytes_sent;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300331
332 return bytes_sent;
333}
334
Alex Williamson760e77e2010-08-19 10:18:42 -0300335static RAMBlock *last_block;
336static ram_addr_t last_offset;
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200337static unsigned long *migration_bitmap;
338static uint64_t migration_dirty_pages;
Alex Williamson760e77e2010-08-19 10:18:42 -0300339
Juan Quintela69268cd2012-07-20 10:36:12 +0200340static inline bool migration_bitmap_test_and_reset_dirty(MemoryRegion *mr,
341 ram_addr_t offset)
342{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200343 bool ret;
344 int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS;
345
346 ret = test_and_clear_bit(nr, migration_bitmap);
Juan Quintela69268cd2012-07-20 10:36:12 +0200347
348 if (ret) {
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200349 migration_dirty_pages--;
Juan Quintela69268cd2012-07-20 10:36:12 +0200350 }
351 return ret;
352}
353
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200354static inline bool migration_bitmap_set_dirty(MemoryRegion *mr,
355 ram_addr_t offset)
Juan Quintelae44d26c2012-07-20 10:16:08 +0200356{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200357 bool ret;
358 int nr = (mr->ram_addr + offset) >> TARGET_PAGE_BITS;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200359
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200360 ret = test_and_set_bit(nr, migration_bitmap);
361
362 if (!ret) {
363 migration_dirty_pages++;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200364 }
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200365 return ret;
Juan Quintelae44d26c2012-07-20 10:16:08 +0200366}
367
Juan Quinteladd2df732012-07-20 10:52:51 +0200368static void migration_bitmap_sync(void)
369{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200370 RAMBlock *block;
371 ram_addr_t addr;
372 uint64_t num_dirty_pages_init = migration_dirty_pages;
Juan Quintela8d017192012-08-13 12:31:25 +0200373 MigrationState *s = migrate_get_current();
374 static int64_t start_time;
375 static int64_t num_dirty_pages_period;
376 int64_t end_time;
377
378 if (!start_time) {
379 start_time = qemu_get_clock_ms(rt_clock);
380 }
Juan Quintela3c121932012-09-04 13:08:57 +0200381
382 trace_migration_bitmap_sync_start();
Juan Quinteladd2df732012-07-20 10:52:51 +0200383 memory_global_sync_dirty_bitmap(get_system_memory());
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200384
385 QLIST_FOREACH(block, &ram_list.blocks, next) {
386 for (addr = 0; addr < block->length; addr += TARGET_PAGE_SIZE) {
387 if (memory_region_get_dirty(block->mr, addr, TARGET_PAGE_SIZE,
388 DIRTY_MEMORY_MIGRATION)) {
389 migration_bitmap_set_dirty(block->mr, addr);
390 }
391 }
392 memory_region_reset_dirty(block->mr, 0, block->length,
393 DIRTY_MEMORY_MIGRATION);
394 }
395 trace_migration_bitmap_sync_end(migration_dirty_pages
Juan Quintela3c121932012-09-04 13:08:57 +0200396 - num_dirty_pages_init);
Juan Quintela8d017192012-08-13 12:31:25 +0200397 num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
398 end_time = qemu_get_clock_ms(rt_clock);
399
400 /* more than 1 second = 1000 millisecons */
401 if (end_time > start_time + 1000) {
402 s->dirty_pages_rate = num_dirty_pages_period * 1000
403 / (end_time - start_time);
404 start_time = end_time;
405 num_dirty_pages_period = 0;
406 }
Juan Quinteladd2df732012-07-20 10:52:51 +0200407}
408
409
Orit Wasserman6c779f22012-07-10 12:37:13 +0300410/*
411 * ram_save_block: Writes a page of memory to the stream f
412 *
413 * Returns: 0: if the page hasn't changed
414 * -1: if there are no more dirty pages
415 * n: the amount of bytes written in other case
416 */
417
Juan Quinteladd051c72012-08-06 21:42:58 +0300418static int ram_save_block(QEMUFile *f, bool last_stage)
Blue Swirlad960902010-03-29 19:23:52 +0000419{
Alex Williamsone44359c2010-06-25 11:09:57 -0600420 RAMBlock *block = last_block;
421 ram_addr_t offset = last_offset;
Orit Wasserman6c779f22012-07-10 12:37:13 +0300422 int bytes_sent = -1;
Avi Kivity71c510e2011-12-21 13:11:22 +0200423 MemoryRegion *mr;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300424 ram_addr_t current_addr;
Blue Swirlad960902010-03-29 19:23:52 +0000425
Alex Williamsone44359c2010-06-25 11:09:57 -0600426 if (!block)
427 block = QLIST_FIRST(&ram_list.blocks);
428
Alex Williamsone44359c2010-06-25 11:09:57 -0600429 do {
Avi Kivity71c510e2011-12-21 13:11:22 +0200430 mr = block->mr;
Juan Quintela69268cd2012-07-20 10:36:12 +0200431 if (migration_bitmap_test_and_reset_dirty(mr, offset)) {
Blue Swirlad960902010-03-29 19:23:52 +0000432 uint8_t *p;
Alex Williamsona55bbe32010-06-25 11:10:05 -0600433 int cont = (block == last_block) ? RAM_SAVE_FLAG_CONTINUE : 0;
Blue Swirlad960902010-03-29 19:23:52 +0000434
Avi Kivity71c510e2011-12-21 13:11:22 +0200435 p = memory_region_get_ram_ptr(mr) + offset;
Blue Swirlad960902010-03-29 19:23:52 +0000436
Paolo Bonzini86003612011-12-23 16:17:26 +0100437 if (is_dup_page(p)) {
Orit Wasserman004d4c12012-08-06 21:42:56 +0300438 acct_info.dup_pages++;
Orit Wasserman0c51f432012-06-19 18:43:14 +0300439 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_COMPRESS);
Blue Swirlad960902010-03-29 19:23:52 +0000440 qemu_put_byte(f, *p);
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200441 bytes_sent = 1;
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300442 } else if (migrate_use_xbzrle()) {
443 current_addr = block->offset + offset;
444 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
Juan Quinteladd051c72012-08-06 21:42:58 +0300445 offset, cont, last_stage);
446 if (!last_stage) {
447 p = get_cached_data(XBZRLE.cache, current_addr);
448 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300449 }
450
451 /* either we didn't send yet (we may have had XBZRLE overflow) */
452 if (bytes_sent == -1) {
Orit Wasserman0c51f432012-06-19 18:43:14 +0300453 save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
Blue Swirlad960902010-03-29 19:23:52 +0000454 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200455 bytes_sent = TARGET_PAGE_SIZE;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300456 acct_info.norm_pages++;
Blue Swirlad960902010-03-29 19:23:52 +0000457 }
458
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300459 /* if page is unmodified, continue to the next */
460 if (bytes_sent != 0) {
461 break;
462 }
Blue Swirlad960902010-03-29 19:23:52 +0000463 }
Alex Williamsone44359c2010-06-25 11:09:57 -0600464
465 offset += TARGET_PAGE_SIZE;
466 if (offset >= block->length) {
467 offset = 0;
468 block = QLIST_NEXT(block, next);
469 if (!block)
470 block = QLIST_FIRST(&ram_list.blocks);
471 }
Avi Kivity71c510e2011-12-21 13:11:22 +0200472 } while (block != last_block || offset != last_offset);
Alex Williamsone44359c2010-06-25 11:09:57 -0600473
474 last_block = block;
475 last_offset = offset;
Blue Swirlad960902010-03-29 19:23:52 +0000476
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200477 return bytes_sent;
Blue Swirlad960902010-03-29 19:23:52 +0000478}
479
480static uint64_t bytes_transferred;
481
482static ram_addr_t ram_save_remaining(void)
483{
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200484 return migration_dirty_pages;
Blue Swirlad960902010-03-29 19:23:52 +0000485}
486
487uint64_t ram_bytes_remaining(void)
488{
489 return ram_save_remaining() * TARGET_PAGE_SIZE;
490}
491
492uint64_t ram_bytes_transferred(void)
493{
494 return bytes_transferred;
495}
496
497uint64_t ram_bytes_total(void)
498{
Alex Williamsond17b5282010-06-25 11:08:38 -0600499 RAMBlock *block;
500 uint64_t total = 0;
501
502 QLIST_FOREACH(block, &ram_list.blocks, next)
503 total += block->length;
504
505 return total;
Blue Swirlad960902010-03-29 19:23:52 +0000506}
507
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +0200508static int block_compar(const void *a, const void *b)
509{
510 RAMBlock * const *ablock = a;
511 RAMBlock * const *bblock = b;
Avi Kivity8fec98b2011-12-21 13:22:16 +0200512
513 return strcmp((*ablock)->idstr, (*bblock)->idstr);
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +0200514}
515
516static void sort_ram_list(void)
517{
518 RAMBlock *block, *nblock, **blocks;
519 int n;
520 n = 0;
521 QLIST_FOREACH(block, &ram_list.blocks, next) {
522 ++n;
523 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500524 blocks = g_malloc(n * sizeof *blocks);
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +0200525 n = 0;
526 QLIST_FOREACH_SAFE(block, &ram_list.blocks, next, nblock) {
527 blocks[n++] = block;
528 QLIST_REMOVE(block, next);
529 }
530 qsort(blocks, n, sizeof *blocks, block_compar);
531 while (--n >= 0) {
532 QLIST_INSERT_HEAD(&ram_list.blocks, blocks[n], next);
533 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500534 g_free(blocks);
Michael S. Tsirkinb2e0a132010-11-22 19:52:34 +0200535}
536
Orit Wasserman8e21cd32012-06-19 18:43:17 +0300537static void migration_end(void)
538{
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100539 if (migration_bitmap) {
540 memory_global_dirty_log_stop();
541 g_free(migration_bitmap);
542 migration_bitmap = NULL;
543 }
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300544
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100545 if (XBZRLE.cache) {
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300546 cache_fini(XBZRLE.cache);
547 g_free(XBZRLE.cache);
548 g_free(XBZRLE.encoded_buf);
549 g_free(XBZRLE.current_buf);
550 g_free(XBZRLE.decoded_buf);
551 XBZRLE.cache = NULL;
552 }
Orit Wasserman8e21cd32012-06-19 18:43:17 +0300553}
554
Juan Quintela9b5bfab2012-06-26 19:26:41 +0200555static void ram_migration_cancel(void *opaque)
556{
557 migration_end();
558}
559
Juan Quintela5a170772012-07-17 17:02:24 +0200560
561static void reset_ram_globals(void)
562{
563 last_block = NULL;
564 last_offset = 0;
565 sort_ram_list();
566}
567
Juan Quintela4508bd92012-05-22 16:27:59 +0200568#define MAX_WAIT 50 /* ms, half buffered_file limit */
569
Juan Quintelad1315aa2012-06-28 15:11:57 +0200570static int ram_save_setup(QEMUFile *f, void *opaque)
Blue Swirlad960902010-03-29 19:23:52 +0000571{
Juan Quintelad1315aa2012-06-28 15:11:57 +0200572 RAMBlock *block;
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200573 int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
574
575 migration_bitmap = bitmap_new(ram_pages);
David Gibson7ec81e52012-12-04 11:38:38 +1100576 bitmap_set(migration_bitmap, 0, ram_pages);
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200577 migration_dirty_pages = ram_pages;
Blue Swirlad960902010-03-29 19:23:52 +0000578
Juan Quintelad1315aa2012-06-28 15:11:57 +0200579 bytes_transferred = 0;
Juan Quintela5a170772012-07-17 17:02:24 +0200580 reset_ram_globals();
Blue Swirlad960902010-03-29 19:23:52 +0000581
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300582 if (migrate_use_xbzrle()) {
583 XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
584 TARGET_PAGE_SIZE,
585 TARGET_PAGE_SIZE);
586 if (!XBZRLE.cache) {
587 DPRINTF("Error creating cache\n");
588 return -1;
589 }
590 XBZRLE.encoded_buf = g_malloc0(TARGET_PAGE_SIZE);
591 XBZRLE.current_buf = g_malloc(TARGET_PAGE_SIZE);
Orit Wasserman004d4c12012-08-06 21:42:56 +0300592 acct_clear();
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300593 }
594
Juan Quintelad1315aa2012-06-28 15:11:57 +0200595 memory_global_dirty_log_start();
Juan Quintelac6bf8e02012-07-20 12:33:00 +0200596 migration_bitmap_sync();
Juan Quintelad1315aa2012-06-28 15:11:57 +0200597
598 qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
599
600 QLIST_FOREACH(block, &ram_list.blocks, next) {
601 qemu_put_byte(f, strlen(block->idstr));
602 qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
603 qemu_put_be64(f, block->length);
604 }
605
Juan Quintelad1315aa2012-06-28 15:11:57 +0200606 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
607
608 return 0;
609}
610
Juan Quintela16310a32012-06-28 15:31:37 +0200611static int ram_save_iterate(QEMUFile *f, void *opaque)
Juan Quintelad1315aa2012-06-28 15:11:57 +0200612{
Alex Williamson97ab12d2010-06-25 11:09:50 -0600613 uint64_t bytes_transferred_last;
614 double bwidth = 0;
Blue Swirlad960902010-03-29 19:23:52 +0000615 int ret;
616 int i;
Juan Quintelac00012f2012-08-13 09:36:36 +0200617 uint64_t expected_downtime;
Juan Quintela2c52ddf2012-08-13 09:53:12 +0200618 MigrationState *s = migrate_get_current();
Blue Swirlad960902010-03-29 19:23:52 +0000619
620 bytes_transferred_last = bytes_transferred;
621 bwidth = qemu_get_clock_ns(rt_clock);
622
Juan Quintela4508bd92012-05-22 16:27:59 +0200623 i = 0;
Juan Quintela29757252011-10-19 15:22:18 +0200624 while ((ret = qemu_file_rate_limit(f)) == 0) {
Pierre Riteau3fc250b2010-05-12 15:12:44 +0200625 int bytes_sent;
Blue Swirlad960902010-03-29 19:23:52 +0000626
Juan Quinteladd051c72012-08-06 21:42:58 +0300627 bytes_sent = ram_save_block(f, false);
Orit Wasserman6c779f22012-07-10 12:37:13 +0300628 /* no more blocks to sent */
629 if (bytes_sent < 0) {
Blue Swirlad960902010-03-29 19:23:52 +0000630 break;
631 }
Orit Wasserman6c779f22012-07-10 12:37:13 +0300632 bytes_transferred += bytes_sent;
Orit Wasserman004d4c12012-08-06 21:42:56 +0300633 acct_info.iterations++;
Juan Quintela4508bd92012-05-22 16:27:59 +0200634 /* we want to check in the 1st loop, just in case it was the 1st time
635 and we had to sync the dirty bitmap.
636 qemu_get_clock_ns() is a bit expensive, so we only check each some
637 iterations
638 */
639 if ((i & 63) == 0) {
640 uint64_t t1 = (qemu_get_clock_ns(rt_clock) - bwidth) / 1000000;
641 if (t1 > MAX_WAIT) {
Igor Mitsyankoef37a692012-09-05 13:04:56 +0400642 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
Juan Quintela4508bd92012-05-22 16:27:59 +0200643 t1, i);
644 break;
645 }
646 }
647 i++;
Blue Swirlad960902010-03-29 19:23:52 +0000648 }
649
Juan Quintela29757252011-10-19 15:22:18 +0200650 if (ret < 0) {
651 return ret;
652 }
653
Blue Swirlad960902010-03-29 19:23:52 +0000654 bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
655 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
656
Juan Quintelac00012f2012-08-13 09:36:36 +0200657 /* if we haven't transferred anything this round, force
658 * expected_downtime to a very high value, but without
659 * crashing */
Blue Swirlad960902010-03-29 19:23:52 +0000660 if (bwidth == 0) {
661 bwidth = 0.000001;
662 }
663
Blue Swirlad960902010-03-29 19:23:52 +0000664 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
665
Juan Quintelac00012f2012-08-13 09:36:36 +0200666 expected_downtime = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
667 DPRINTF("ram_save_live: expected(%" PRIu64 ") <= max(" PRIu64 ")?\n",
668 expected_downtime, migrate_max_downtime());
Blue Swirlad960902010-03-29 19:23:52 +0000669
Juan Quintelac00012f2012-08-13 09:36:36 +0200670 if (expected_downtime <= migrate_max_downtime()) {
Juan Quinteladd2df732012-07-20 10:52:51 +0200671 migration_bitmap_sync();
Juan Quintelac00012f2012-08-13 09:36:36 +0200672 expected_downtime = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
Juan Quintela2c52ddf2012-08-13 09:53:12 +0200673 s->expected_downtime = expected_downtime / 1000000; /* ns -> ms */
Orit Wasserman3a697f62012-06-19 18:43:15 +0300674
Juan Quintelac00012f2012-08-13 09:36:36 +0200675 return expected_downtime <= migrate_max_downtime();
Juan Quintela5b3c9632012-05-22 00:44:24 +0200676 }
677 return 0;
Blue Swirlad960902010-03-29 19:23:52 +0000678}
679
Juan Quintela16310a32012-06-28 15:31:37 +0200680static int ram_save_complete(QEMUFile *f, void *opaque)
681{
Juan Quinteladd2df732012-07-20 10:52:51 +0200682 migration_bitmap_sync();
Juan Quintela16310a32012-06-28 15:31:37 +0200683
Juan Quintela16310a32012-06-28 15:31:37 +0200684 /* try transferring iterative blocks of memory */
685
686 /* flush all remaining blocks regardless of rate limiting */
Orit Wasserman6c779f22012-07-10 12:37:13 +0300687 while (true) {
688 int bytes_sent;
689
Juan Quinteladd051c72012-08-06 21:42:58 +0300690 bytes_sent = ram_save_block(f, true);
Orit Wasserman6c779f22012-07-10 12:37:13 +0300691 /* no more blocks to sent */
692 if (bytes_sent < 0) {
693 break;
694 }
Juan Quintela16310a32012-06-28 15:31:37 +0200695 bytes_transferred += bytes_sent;
696 }
Paolo Bonzini244eaa72012-12-12 12:54:43 +0100697 migration_end();
Juan Quintela16310a32012-06-28 15:31:37 +0200698
Blue Swirlad960902010-03-29 19:23:52 +0000699 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
700
Alex Williamsona55bbe32010-06-25 11:10:05 -0600701 return 0;
702}
703
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300704static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
705{
706 int ret, rc = 0;
707 unsigned int xh_len;
708 int xh_flags;
709
710 if (!XBZRLE.decoded_buf) {
711 XBZRLE.decoded_buf = g_malloc(TARGET_PAGE_SIZE);
712 }
713
714 /* extract RLE header */
715 xh_flags = qemu_get_byte(f);
716 xh_len = qemu_get_be16(f);
717
718 if (xh_flags != ENCODING_FLAG_XBZRLE) {
719 fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
720 return -1;
721 }
722
723 if (xh_len > TARGET_PAGE_SIZE) {
724 fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
725 return -1;
726 }
727 /* load data and decode */
728 qemu_get_buffer(f, XBZRLE.decoded_buf, xh_len);
729
730 /* decode RLE */
731 ret = xbzrle_decode_buffer(XBZRLE.decoded_buf, xh_len, host,
732 TARGET_PAGE_SIZE);
733 if (ret == -1) {
734 fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
735 rc = -1;
736 } else if (ret > TARGET_PAGE_SIZE) {
737 fprintf(stderr, "Failed to load XBZRLE page - size %d exceeds %d!\n",
738 ret, TARGET_PAGE_SIZE);
739 abort();
740 }
741
742 return rc;
743}
744
Alex Williamsona55bbe32010-06-25 11:10:05 -0600745static inline void *host_from_stream_offset(QEMUFile *f,
746 ram_addr_t offset,
747 int flags)
748{
749 static RAMBlock *block = NULL;
750 char id[256];
751 uint8_t len;
752
753 if (flags & RAM_SAVE_FLAG_CONTINUE) {
754 if (!block) {
755 fprintf(stderr, "Ack, bad migration stream!\n");
756 return NULL;
757 }
758
Avi Kivitydc94a7e2011-12-21 13:54:33 +0200759 return memory_region_get_ram_ptr(block->mr) + offset;
Alex Williamsona55bbe32010-06-25 11:10:05 -0600760 }
761
762 len = qemu_get_byte(f);
763 qemu_get_buffer(f, (uint8_t *)id, len);
764 id[len] = 0;
765
766 QLIST_FOREACH(block, &ram_list.blocks, next) {
767 if (!strncmp(id, block->idstr, sizeof(id)))
Avi Kivitydc94a7e2011-12-21 13:54:33 +0200768 return memory_region_get_ram_ptr(block->mr) + offset;
Alex Williamsona55bbe32010-06-25 11:10:05 -0600769 }
770
771 fprintf(stderr, "Can't find block %s!\n", id);
772 return NULL;
773}
774
Juan Quintela7908c782012-06-26 18:46:10 +0200775static int ram_load(QEMUFile *f, void *opaque, int version_id)
Blue Swirlad960902010-03-29 19:23:52 +0000776{
777 ram_addr_t addr;
Orit Wasserman3a697f62012-06-19 18:43:15 +0300778 int flags, ret = 0;
Juan Quintela42802d42011-10-05 01:14:46 +0200779 int error;
Orit Wasserman3a697f62012-06-19 18:43:15 +0300780 static uint64_t seq_iter;
781
782 seq_iter++;
Blue Swirlad960902010-03-29 19:23:52 +0000783
Avi Kivityf09f2182011-12-21 13:37:56 +0200784 if (version_id < 4 || version_id > 4) {
Blue Swirlad960902010-03-29 19:23:52 +0000785 return -EINVAL;
786 }
787
788 do {
789 addr = qemu_get_be64(f);
790
791 flags = addr & ~TARGET_PAGE_MASK;
792 addr &= TARGET_PAGE_MASK;
793
794 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
Avi Kivityf09f2182011-12-21 13:37:56 +0200795 if (version_id == 4) {
Alex Williamson97ab12d2010-06-25 11:09:50 -0600796 /* Synchronize RAM block list */
797 char id[256];
798 ram_addr_t length;
799 ram_addr_t total_ram_bytes = addr;
800
801 while (total_ram_bytes) {
802 RAMBlock *block;
803 uint8_t len;
804
805 len = qemu_get_byte(f);
806 qemu_get_buffer(f, (uint8_t *)id, len);
807 id[len] = 0;
808 length = qemu_get_be64(f);
809
810 QLIST_FOREACH(block, &ram_list.blocks, next) {
811 if (!strncmp(id, block->idstr, sizeof(id))) {
Orit Wasserman3a697f62012-06-19 18:43:15 +0300812 if (block->length != length) {
813 ret = -EINVAL;
814 goto done;
815 }
Alex Williamson97ab12d2010-06-25 11:09:50 -0600816 break;
817 }
818 }
819
820 if (!block) {
Alex Williamsonfb787f82010-07-02 11:13:29 -0600821 fprintf(stderr, "Unknown ramblock \"%s\", cannot "
822 "accept migration\n", id);
Orit Wasserman3a697f62012-06-19 18:43:15 +0300823 ret = -EINVAL;
824 goto done;
Alex Williamson97ab12d2010-06-25 11:09:50 -0600825 }
826
827 total_ram_bytes -= length;
828 }
Blue Swirlad960902010-03-29 19:23:52 +0000829 }
830 }
831
832 if (flags & RAM_SAVE_FLAG_COMPRESS) {
Alex Williamson97ab12d2010-06-25 11:09:50 -0600833 void *host;
834 uint8_t ch;
835
Avi Kivityf09f2182011-12-21 13:37:56 +0200836 host = host_from_stream_offset(f, addr, flags);
Michael S. Tsirkin492fb992010-10-17 20:43:40 +0200837 if (!host) {
838 return -EINVAL;
839 }
Alex Williamson97ab12d2010-06-25 11:09:50 -0600840
Alex Williamson97ab12d2010-06-25 11:09:50 -0600841 ch = qemu_get_byte(f);
842 memset(host, ch, TARGET_PAGE_SIZE);
Blue Swirlad960902010-03-29 19:23:52 +0000843#ifndef _WIN32
844 if (ch == 0 &&
David Gibson45e6cee2012-12-04 11:38:39 +1100845 (!kvm_enabled() || kvm_has_sync_mmu()) &&
846 getpagesize() <= TARGET_PAGE_SIZE) {
Andreas Färbere78815a2010-09-25 11:26:05 +0000847 qemu_madvise(host, TARGET_PAGE_SIZE, QEMU_MADV_DONTNEED);
Blue Swirlad960902010-03-29 19:23:52 +0000848 }
849#endif
850 } else if (flags & RAM_SAVE_FLAG_PAGE) {
Alex Williamson97ab12d2010-06-25 11:09:50 -0600851 void *host;
852
Avi Kivityf09f2182011-12-21 13:37:56 +0200853 host = host_from_stream_offset(f, addr, flags);
Orit Wasserman0ff1f9f2012-06-19 11:51:37 +0300854 if (!host) {
855 return -EINVAL;
856 }
Alex Williamson97ab12d2010-06-25 11:09:50 -0600857
Alex Williamson97ab12d2010-06-25 11:09:50 -0600858 qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
Orit Wasserman17ad9b32012-08-06 21:42:53 +0300859 } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
860 if (!migrate_use_xbzrle()) {
861 return -EINVAL;
862 }
863 void *host = host_from_stream_offset(f, addr, flags);
864 if (!host) {
865 return -EINVAL;
866 }
867
868 if (load_xbzrle(f, addr, host) < 0) {
869 ret = -EINVAL;
870 goto done;
871 }
Blue Swirlad960902010-03-29 19:23:52 +0000872 }
Juan Quintela42802d42011-10-05 01:14:46 +0200873 error = qemu_file_get_error(f);
874 if (error) {
Orit Wasserman3a697f62012-06-19 18:43:15 +0300875 ret = error;
876 goto done;
Blue Swirlad960902010-03-29 19:23:52 +0000877 }
878 } while (!(flags & RAM_SAVE_FLAG_EOS));
879
Orit Wasserman3a697f62012-06-19 18:43:15 +0300880done:
Igor Mitsyankoef37a692012-09-05 13:04:56 +0400881 DPRINTF("Completed load of VM with exit code %d seq iteration "
882 "%" PRIu64 "\n", ret, seq_iter);
Orit Wasserman3a697f62012-06-19 18:43:15 +0300883 return ret;
Blue Swirlad960902010-03-29 19:23:52 +0000884}
885
Juan Quintela7908c782012-06-26 18:46:10 +0200886SaveVMHandlers savevm_ram_handlers = {
Juan Quintelad1315aa2012-06-28 15:11:57 +0200887 .save_live_setup = ram_save_setup,
Juan Quintela16310a32012-06-28 15:31:37 +0200888 .save_live_iterate = ram_save_iterate,
889 .save_live_complete = ram_save_complete,
Juan Quintela7908c782012-06-26 18:46:10 +0200890 .load_state = ram_load,
Juan Quintela9b5bfab2012-06-26 19:26:41 +0200891 .cancel = ram_migration_cancel,
Juan Quintela7908c782012-06-26 18:46:10 +0200892};
893
Blue Swirlad960902010-03-29 19:23:52 +0000894#ifdef HAS_AUDIO
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +0900895struct soundhw {
896 const char *name;
897 const char *descr;
898 int enabled;
899 int isa;
900 union {
Hervé Poussineau4a0f0312011-12-15 22:10:01 +0100901 int (*init_isa) (ISABus *bus);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +0900902 int (*init_pci) (PCIBus *bus);
903 } init;
904};
905
906static struct soundhw soundhw[] = {
Blue Swirlad960902010-03-29 19:23:52 +0000907#ifdef HAS_AUDIO_CHOICE
Hervé Poussineauda128722012-04-14 22:51:33 +0200908#ifdef CONFIG_PCSPK
Blue Swirlad960902010-03-29 19:23:52 +0000909 {
910 "pcspk",
911 "PC speaker",
912 0,
913 1,
914 { .init_isa = pcspk_audio_init }
915 },
916#endif
917
918#ifdef CONFIG_SB16
919 {
920 "sb16",
921 "Creative Sound Blaster 16",
922 0,
923 1,
924 { .init_isa = SB16_init }
925 },
926#endif
927
928#ifdef CONFIG_CS4231A
929 {
930 "cs4231a",
931 "CS4231A",
932 0,
933 1,
934 { .init_isa = cs4231a_init }
935 },
936#endif
937
938#ifdef CONFIG_ADLIB
939 {
940 "adlib",
941#ifdef HAS_YMF262
942 "Yamaha YMF262 (OPL3)",
943#else
944 "Yamaha YM3812 (OPL2)",
945#endif
946 0,
947 1,
948 { .init_isa = Adlib_init }
949 },
950#endif
951
952#ifdef CONFIG_GUS
953 {
954 "gus",
955 "Gravis Ultrasound GF1",
956 0,
957 1,
958 { .init_isa = GUS_init }
959 },
960#endif
961
962#ifdef CONFIG_AC97
963 {
964 "ac97",
965 "Intel 82801AA AC97 Audio",
966 0,
967 0,
968 { .init_pci = ac97_init }
969 },
970#endif
971
972#ifdef CONFIG_ES1370
973 {
974 "es1370",
975 "ENSONIQ AudioPCI ES1370",
976 0,
977 0,
978 { .init_pci = es1370_init }
979 },
980#endif
981
Gerd Hoffmannd61a4ce2010-11-01 13:05:32 +0100982#ifdef CONFIG_HDA
983 {
984 "hda",
985 "Intel HD Audio",
986 0,
987 0,
988 { .init_pci = intel_hda_and_codec_init }
989 },
990#endif
991
Blue Swirlad960902010-03-29 19:23:52 +0000992#endif /* HAS_AUDIO_CHOICE */
993
994 { NULL, NULL, 0, 0, { NULL } }
995};
996
997void select_soundhw(const char *optarg)
998{
999 struct soundhw *c;
1000
Peter Maydellc8057f92012-08-02 13:45:54 +01001001 if (is_help_option(optarg)) {
Blue Swirlad960902010-03-29 19:23:52 +00001002 show_valid_cards:
1003
Peter Maydell55d4fd32012-09-19 14:51:38 +01001004#ifdef HAS_AUDIO_CHOICE
Blue Swirlad960902010-03-29 19:23:52 +00001005 printf("Valid sound card names (comma separated):\n");
1006 for (c = soundhw; c->name; ++c) {
1007 printf ("%-11s %s\n", c->name, c->descr);
1008 }
1009 printf("\n-soundhw all will enable all of the above\n");
Peter Maydell55d4fd32012-09-19 14:51:38 +01001010#else
1011 printf("Machine has no user-selectable audio hardware "
1012 "(it may or may not have always-present audio hardware).\n");
1013#endif
Peter Maydellc8057f92012-08-02 13:45:54 +01001014 exit(!is_help_option(optarg));
Blue Swirlad960902010-03-29 19:23:52 +00001015 }
1016 else {
1017 size_t l;
1018 const char *p;
1019 char *e;
1020 int bad_card = 0;
1021
1022 if (!strcmp(optarg, "all")) {
1023 for (c = soundhw; c->name; ++c) {
1024 c->enabled = 1;
1025 }
1026 return;
1027 }
1028
1029 p = optarg;
1030 while (*p) {
1031 e = strchr(p, ',');
1032 l = !e ? strlen(p) : (size_t) (e - p);
1033
1034 for (c = soundhw; c->name; ++c) {
1035 if (!strncmp(c->name, p, l) && !c->name[l]) {
1036 c->enabled = 1;
1037 break;
1038 }
1039 }
1040
1041 if (!c->name) {
1042 if (l > 80) {
1043 fprintf(stderr,
1044 "Unknown sound card name (too big to show)\n");
1045 }
1046 else {
1047 fprintf(stderr, "Unknown sound card name `%.*s'\n",
1048 (int) l, p);
1049 }
1050 bad_card = 1;
1051 }
1052 p += l + (e != NULL);
1053 }
1054
1055 if (bad_card) {
1056 goto show_valid_cards;
1057 }
1058 }
1059}
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001060
Hervé Poussineau4a0f0312011-12-15 22:10:01 +01001061void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001062{
1063 struct soundhw *c;
1064
1065 for (c = soundhw; c->name; ++c) {
1066 if (c->enabled) {
1067 if (c->isa) {
Hervé Poussineau4a0f0312011-12-15 22:10:01 +01001068 if (isa_bus) {
1069 c->init.init_isa(isa_bus);
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001070 }
1071 } else {
1072 if (pci_bus) {
1073 c->init.init_pci(pci_bus);
1074 }
1075 }
1076 }
1077 }
1078}
Blue Swirlad960902010-03-29 19:23:52 +00001079#else
1080void select_soundhw(const char *optarg)
1081{
1082}
Hervé Poussineau4a0f0312011-12-15 22:10:01 +01001083void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
Isaku Yamahata0dfa5ef2011-01-21 19:53:45 +09001084{
1085}
Blue Swirlad960902010-03-29 19:23:52 +00001086#endif
1087
1088int qemu_uuid_parse(const char *str, uint8_t *uuid)
1089{
1090 int ret;
1091
1092 if (strlen(str) != 36) {
1093 return -1;
1094 }
1095
1096 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
1097 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
1098 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
1099 &uuid[15]);
1100
1101 if (ret != 16) {
1102 return -1;
1103 }
1104#ifdef TARGET_I386
1105 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
1106#endif
1107 return 0;
1108}
1109
1110void do_acpitable_option(const char *optarg)
1111{
1112#ifdef TARGET_I386
1113 if (acpi_table_add(optarg) < 0) {
1114 fprintf(stderr, "Wrong acpi table provided\n");
1115 exit(1);
1116 }
1117#endif
1118}
1119
1120void do_smbios_option(const char *optarg)
1121{
1122#ifdef TARGET_I386
1123 if (smbios_entry_add(optarg) < 0) {
1124 fprintf(stderr, "Wrong smbios provided\n");
1125 exit(1);
1126 }
1127#endif
1128}
1129
1130void cpudef_init(void)
1131{
1132#if defined(cpudef_setup)
1133 cpudef_setup(); /* parse cpu definitions in target config file */
1134#endif
1135}
1136
1137int audio_available(void)
1138{
1139#ifdef HAS_AUDIO
1140 return 1;
1141#else
1142 return 0;
1143#endif
1144}
1145
Anthony PERARD303d4e82010-09-21 20:05:31 +01001146int tcg_available(void)
1147{
1148 return 1;
1149}
1150
Blue Swirlad960902010-03-29 19:23:52 +00001151int kvm_available(void)
1152{
1153#ifdef CONFIG_KVM
1154 return 1;
1155#else
1156 return 0;
1157#endif
1158}
1159
1160int xen_available(void)
1161{
1162#ifdef CONFIG_XEN
1163 return 1;
1164#else
1165 return 0;
1166#endif
1167}
Daniel P. Berrange99afc912012-08-20 15:31:38 +01001168
1169
1170TargetInfo *qmp_query_target(Error **errp)
1171{
1172 TargetInfo *info = g_malloc0(sizeof(*info));
1173
1174 info->arch = TARGET_TYPE;
1175
1176 return info;
1177}