]> git.proxmox.com Git - mirror_qemu.git/blame_incremental - vl.c
projects / mirror_qemu.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
virtio-net: implement async packet sending
[mirror_qemu.git] / vl.c
... / ...
CommitLineData
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 <unistd.h>
25#include <fcntl.h>
26#include <signal.h>
27#include <time.h>
28#include <errno.h>
29#include <sys/time.h>
30#include <zlib.h>
31
32/* Needed early for HOST_BSD etc. */
33#include "config-host.h"
34
35#ifndef _WIN32
36#include <libgen.h>
37#include <pwd.h>
38#include <sys/times.h>
39#include <sys/wait.h>
40#include <termios.h>
41#include <sys/mman.h>
42#include <sys/ioctl.h>
43#include <sys/resource.h>
44#include <sys/socket.h>
45#include <netinet/in.h>
46#include <net/if.h>
47#if defined(__NetBSD__)
48#include <net/if_tap.h>
49#endif
50#ifdef __linux__
51#include <linux/if_tun.h>
52#endif
53#include <arpa/inet.h>
54#include <dirent.h>
55#include <netdb.h>
56#include <sys/select.h>
57#ifdef HOST_BSD
58#include <sys/stat.h>
59#if defined(__FreeBSD__) || defined(__DragonFly__)
60#include <libutil.h>
61#else
62#include <util.h>
63#endif
64#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
65#include <freebsd/stdlib.h>
66#else
67#ifdef __linux__
68#include <pty.h>
69#include <malloc.h>
70#include <linux/rtc.h>
71
72/* For the benefit of older linux systems which don't supply it,
73 we use a local copy of hpet.h. */
74/* #include <linux/hpet.h> */
75#include "hpet.h"
76
77#include <linux/ppdev.h>
78#include <linux/parport.h>
79#endif
80#ifdef __sun__
81#include <sys/stat.h>
82#include <sys/ethernet.h>
83#include <sys/sockio.h>
84#include <netinet/arp.h>
85#include <netinet/in.h>
86#include <netinet/in_systm.h>
87#include <netinet/ip.h>
88#include <netinet/ip_icmp.h> // must come after ip.h
89#include <netinet/udp.h>
90#include <netinet/tcp.h>
91#include <net/if.h>
92#include <syslog.h>
93#include <stropts.h>
94#endif
95#endif
96#endif
97
98#if defined(__OpenBSD__)
99#include <util.h>
100#endif
101
102#if defined(CONFIG_VDE)
103#include <libvdeplug.h>
104#endif
105
106#ifdef _WIN32
107#include <windows.h>
108#include <malloc.h>
109#include <sys/timeb.h>
110#include <mmsystem.h>
111#define getopt_long_only getopt_long
112#define memalign(align, size) malloc(size)
113#endif
114
115#ifdef CONFIG_SDL
116#ifdef __APPLE__
117#include <SDL.h>
118int qemu_main(int argc, char **argv, char **envp);
119int main(int argc, char **argv)
120{
121 qemu_main(argc, argv, NULL);
122}
123#undef main
124#define main qemu_main
125#endif
126#endif /* CONFIG_SDL */
127
128#ifdef CONFIG_COCOA
129#undef main
130#define main qemu_main
131#endif /* CONFIG_COCOA */
132
133#include "hw/hw.h"
134#include "hw/boards.h"
135#include "hw/usb.h"
136#include "hw/pcmcia.h"
137#include "hw/pc.h"
138#include "hw/audiodev.h"
139#include "hw/isa.h"
140#include "hw/baum.h"
141#include "hw/bt.h"
142#include "hw/watchdog.h"
143#include "hw/smbios.h"
144#include "hw/xen.h"
145#include "bt-host.h"
146#include "net.h"
147#include "monitor.h"
148#include "console.h"
149#include "sysemu.h"
150#include "gdbstub.h"
151#include "qemu-timer.h"
152#include "qemu-char.h"
153#include "cache-utils.h"
154#include "block.h"
155#include "dma.h"
156#include "audio/audio.h"
157#include "migration.h"
158#include "kvm.h"
159#include "balloon.h"
160#include "qemu-option.h"
161
162#include "disas.h"
163
164#include "exec-all.h"
165
166#include "qemu_socket.h"
167
168#if defined(CONFIG_SLIRP)
169#include "libslirp.h"
170#endif
171
172//#define DEBUG_UNUSED_IOPORT
173//#define DEBUG_IOPORT
174//#define DEBUG_NET
175//#define DEBUG_SLIRP
176
177
178#ifdef DEBUG_IOPORT
179# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
180#else
181# define LOG_IOPORT(...) do { } while (0)
182#endif
183
184#define DEFAULT_RAM_SIZE 128
185
186/* Max number of USB devices that can be specified on the commandline. */
187#define MAX_USB_CMDLINE 8
188
189/* Max number of bluetooth switches on the commandline. */
190#define MAX_BT_CMDLINE 10
191
192/* XXX: use a two level table to limit memory usage */
193#define MAX_IOPORTS 65536
194
195static const char *data_dir;
196const char *bios_name = NULL;
197static void *ioport_opaque[MAX_IOPORTS];
198static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
199static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
200/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
201 to store the VM snapshots */
202DriveInfo drives_table[MAX_DRIVES+1];
203int nb_drives;
204enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
205static DisplayState *display_state;
206DisplayType display_type = DT_DEFAULT;
207const char* keyboard_layout = NULL;
208int64_t ticks_per_sec;
209ram_addr_t ram_size;
210int nb_nics;
211NICInfo nd_table[MAX_NICS];
212int vm_running;
213static int autostart;
214static int rtc_utc = 1;
215static int rtc_date_offset = -1; /* -1 means no change */
216int cirrus_vga_enabled = 1;
217int std_vga_enabled = 0;
218int vmsvga_enabled = 0;
219int xenfb_enabled = 0;
220#ifdef TARGET_SPARC
221int graphic_width = 1024;
222int graphic_height = 768;
223int graphic_depth = 8;
224#else
225int graphic_width = 800;
226int graphic_height = 600;
227int graphic_depth = 15;
228#endif
229static int full_screen = 0;
230#ifdef CONFIG_SDL
231static int no_frame = 0;
232#endif
233int no_quit = 0;
234CharDriverState *serial_hds[MAX_SERIAL_PORTS];
235CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
236CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
237#ifdef TARGET_I386
238int win2k_install_hack = 0;
239int rtc_td_hack = 0;
240#endif
241int usb_enabled = 0;
242int singlestep = 0;
243int smp_cpus = 1;
244const char *vnc_display;
245int acpi_enabled = 1;
246int no_hpet = 0;
247int no_virtio_balloon = 0;
248int fd_bootchk = 1;
249int no_reboot = 0;
250int no_shutdown = 0;
251int cursor_hide = 1;
252int graphic_rotate = 0;
253#ifndef _WIN32
254int daemonize = 0;
255#endif
256WatchdogTimerModel *watchdog = NULL;
257int watchdog_action = WDT_RESET;
258const char *option_rom[MAX_OPTION_ROMS];
259int nb_option_roms;
260int semihosting_enabled = 0;
261#ifdef TARGET_ARM
262int old_param = 0;
263#endif
264const char *qemu_name;
265int alt_grab = 0;
266#if defined(TARGET_SPARC) || defined(TARGET_PPC)
267unsigned int nb_prom_envs = 0;
268const char *prom_envs[MAX_PROM_ENVS];
269#endif
270int nb_drives_opt;
271struct drive_opt drives_opt[MAX_DRIVES];
272
273int nb_numa_nodes;
274uint64_t node_mem[MAX_NODES];
275uint64_t node_cpumask[MAX_NODES];
276
277static CPUState *cur_cpu;
278static CPUState *next_cpu;
279static int timer_alarm_pending = 1;
280/* Conversion factor from emulated instructions to virtual clock ticks. */
281static int icount_time_shift;
282/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
283#define MAX_ICOUNT_SHIFT 10
284/* Compensate for varying guest execution speed. */
285static int64_t qemu_icount_bias;
286static QEMUTimer *icount_rt_timer;
287static QEMUTimer *icount_vm_timer;
288static QEMUTimer *nographic_timer;
289
290uint8_t qemu_uuid[16];
291
292/***********************************************************/
293/* x86 ISA bus support */
294
295target_phys_addr_t isa_mem_base = 0;
296PicState2 *isa_pic;
297
298static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
299static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
300
301static uint32_t ioport_read(int index, uint32_t address)
302{
303 static IOPortReadFunc *default_func[3] = {
304 default_ioport_readb,
305 default_ioport_readw,
306 default_ioport_readl
307 };
308 IOPortReadFunc *func = ioport_read_table[index][address];
309 if (!func)
310 func = default_func[index];
311 return func(ioport_opaque[address], address);
312}
313
314static void ioport_write(int index, uint32_t address, uint32_t data)
315{
316 static IOPortWriteFunc *default_func[3] = {
317 default_ioport_writeb,
318 default_ioport_writew,
319 default_ioport_writel
320 };
321 IOPortWriteFunc *func = ioport_write_table[index][address];
322 if (!func)
323 func = default_func[index];
324 func(ioport_opaque[address], address, data);
325}
326
327static uint32_t default_ioport_readb(void *opaque, uint32_t address)
328{
329#ifdef DEBUG_UNUSED_IOPORT
330 fprintf(stderr, "unused inb: port=0x%04x\n", address);
331#endif
332 return 0xff;
333}
334
335static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
336{
337#ifdef DEBUG_UNUSED_IOPORT
338 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
339#endif
340}
341
342/* default is to make two byte accesses */
343static uint32_t default_ioport_readw(void *opaque, uint32_t address)
344{
345 uint32_t data;
346 data = ioport_read(0, address);
347 address = (address + 1) & (MAX_IOPORTS - 1);
348 data |= ioport_read(0, address) << 8;
349 return data;
350}
351
352static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
353{
354 ioport_write(0, address, data & 0xff);
355 address = (address + 1) & (MAX_IOPORTS - 1);
356 ioport_write(0, address, (data >> 8) & 0xff);
357}
358
359static uint32_t default_ioport_readl(void *opaque, uint32_t address)
360{
361#ifdef DEBUG_UNUSED_IOPORT
362 fprintf(stderr, "unused inl: port=0x%04x\n", address);
363#endif
364 return 0xffffffff;
365}
366
367static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
368{
369#ifdef DEBUG_UNUSED_IOPORT
370 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
371#endif
372}
373
374/* size is the word size in byte */
375int register_ioport_read(int start, int length, int size,
376 IOPortReadFunc *func, void *opaque)
377{
378 int i, bsize;
379
380 if (size == 1) {
381 bsize = 0;
382 } else if (size == 2) {
383 bsize = 1;
384 } else if (size == 4) {
385 bsize = 2;
386 } else {
387 hw_error("register_ioport_read: invalid size");
388 return -1;
389 }
390 for(i = start; i < start + length; i += size) {
391 ioport_read_table[bsize][i] = func;
392 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
393 hw_error("register_ioport_read: invalid opaque");
394 ioport_opaque[i] = opaque;
395 }
396 return 0;
397}
398
399/* size is the word size in byte */
400int register_ioport_write(int start, int length, int size,
401 IOPortWriteFunc *func, void *opaque)
402{
403 int i, bsize;
404
405 if (size == 1) {
406 bsize = 0;
407 } else if (size == 2) {
408 bsize = 1;
409 } else if (size == 4) {
410 bsize = 2;
411 } else {
412 hw_error("register_ioport_write: invalid size");
413 return -1;
414 }
415 for(i = start; i < start + length; i += size) {
416 ioport_write_table[bsize][i] = func;
417 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
418 hw_error("register_ioport_write: invalid opaque");
419 ioport_opaque[i] = opaque;
420 }
421 return 0;
422}
423
424void isa_unassign_ioport(int start, int length)
425{
426 int i;
427
428 for(i = start; i < start + length; i++) {
429 ioport_read_table[0][i] = default_ioport_readb;
430 ioport_read_table[1][i] = default_ioport_readw;
431 ioport_read_table[2][i] = default_ioport_readl;
432
433 ioport_write_table[0][i] = default_ioport_writeb;
434 ioport_write_table[1][i] = default_ioport_writew;
435 ioport_write_table[2][i] = default_ioport_writel;
436
437 ioport_opaque[i] = NULL;
438 }
439}
440
441/***********************************************************/
442
443void cpu_outb(CPUState *env, int addr, int val)
444{
445 LOG_IOPORT("outb: %04x %02x\n", addr, val);
446 ioport_write(0, addr, val);
447#ifdef CONFIG_KQEMU
448 if (env)
449 env->last_io_time = cpu_get_time_fast();
450#endif
451}
452
453void cpu_outw(CPUState *env, int addr, int val)
454{
455 LOG_IOPORT("outw: %04x %04x\n", addr, val);
456 ioport_write(1, addr, val);
457#ifdef CONFIG_KQEMU
458 if (env)
459 env->last_io_time = cpu_get_time_fast();
460#endif
461}
462
463void cpu_outl(CPUState *env, int addr, int val)
464{
465 LOG_IOPORT("outl: %04x %08x\n", addr, val);
466 ioport_write(2, addr, val);
467#ifdef CONFIG_KQEMU
468 if (env)
469 env->last_io_time = cpu_get_time_fast();
470#endif
471}
472
473int cpu_inb(CPUState *env, int addr)
474{
475 int val;
476 val = ioport_read(0, addr);
477 LOG_IOPORT("inb : %04x %02x\n", addr, val);
478#ifdef CONFIG_KQEMU
479 if (env)
480 env->last_io_time = cpu_get_time_fast();
481#endif
482 return val;
483}
484
485int cpu_inw(CPUState *env, int addr)
486{
487 int val;
488 val = ioport_read(1, addr);
489 LOG_IOPORT("inw : %04x %04x\n", addr, val);
490#ifdef CONFIG_KQEMU
491 if (env)
492 env->last_io_time = cpu_get_time_fast();
493#endif
494 return val;
495}
496
497int cpu_inl(CPUState *env, int addr)
498{
499 int val;
500 val = ioport_read(2, addr);
501 LOG_IOPORT("inl : %04x %08x\n", addr, val);
502#ifdef CONFIG_KQEMU
503 if (env)
504 env->last_io_time = cpu_get_time_fast();
505#endif
506 return val;
507}
508
509/***********************************************************/
510void hw_error(const char *fmt, ...)
511{
512 va_list ap;
513 CPUState *env;
514
515 va_start(ap, fmt);
516 fprintf(stderr, "qemu: hardware error: ");
517 vfprintf(stderr, fmt, ap);
518 fprintf(stderr, "\n");
519 for(env = first_cpu; env != NULL; env = env->next_cpu) {
520 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
521#ifdef TARGET_I386
522 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
523#else
524 cpu_dump_state(env, stderr, fprintf, 0);
525#endif
526 }
527 va_end(ap);
528 abort();
529}
530
531/***************/
532/* ballooning */
533
534static QEMUBalloonEvent *qemu_balloon_event;
535void *qemu_balloon_event_opaque;
536
537void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
538{
539 qemu_balloon_event = func;
540 qemu_balloon_event_opaque = opaque;
541}
542
543void qemu_balloon(ram_addr_t target)
544{
545 if (qemu_balloon_event)
546 qemu_balloon_event(qemu_balloon_event_opaque, target);
547}
548
549ram_addr_t qemu_balloon_status(void)
550{
551 if (qemu_balloon_event)
552 return qemu_balloon_event(qemu_balloon_event_opaque, 0);
553 return 0;
554}
555
556/***********************************************************/
557/* keyboard/mouse */
558
559static QEMUPutKBDEvent *qemu_put_kbd_event;
560static void *qemu_put_kbd_event_opaque;
561static QEMUPutMouseEntry *qemu_put_mouse_event_head;
562static QEMUPutMouseEntry *qemu_put_mouse_event_current;
563
564void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
565{
566 qemu_put_kbd_event_opaque = opaque;
567 qemu_put_kbd_event = func;
568}
569
570QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
571 void *opaque, int absolute,
572 const char *name)
573{
574 QEMUPutMouseEntry *s, *cursor;
575
576 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
577
578 s->qemu_put_mouse_event = func;
579 s->qemu_put_mouse_event_opaque = opaque;
580 s->qemu_put_mouse_event_absolute = absolute;
581 s->qemu_put_mouse_event_name = qemu_strdup(name);
582 s->next = NULL;
583
584 if (!qemu_put_mouse_event_head) {
585 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
586 return s;
587 }
588
589 cursor = qemu_put_mouse_event_head;
590 while (cursor->next != NULL)
591 cursor = cursor->next;
592
593 cursor->next = s;
594 qemu_put_mouse_event_current = s;
595
596 return s;
597}
598
599void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
600{
601 QEMUPutMouseEntry *prev = NULL, *cursor;
602
603 if (!qemu_put_mouse_event_head || entry == NULL)
604 return;
605
606 cursor = qemu_put_mouse_event_head;
607 while (cursor != NULL && cursor != entry) {
608 prev = cursor;
609 cursor = cursor->next;
610 }
611
612 if (cursor == NULL) // does not exist or list empty
613 return;
614 else if (prev == NULL) { // entry is head
615 qemu_put_mouse_event_head = cursor->next;
616 if (qemu_put_mouse_event_current == entry)
617 qemu_put_mouse_event_current = cursor->next;
618 qemu_free(entry->qemu_put_mouse_event_name);
619 qemu_free(entry);
620 return;
621 }
622
623 prev->next = entry->next;
624
625 if (qemu_put_mouse_event_current == entry)
626 qemu_put_mouse_event_current = prev;
627
628 qemu_free(entry->qemu_put_mouse_event_name);
629 qemu_free(entry);
630}
631
632void kbd_put_keycode(int keycode)
633{
634 if (qemu_put_kbd_event) {
635 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
636 }
637}
638
639void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
640{
641 QEMUPutMouseEvent *mouse_event;
642 void *mouse_event_opaque;
643 int width;
644
645 if (!qemu_put_mouse_event_current) {
646 return;
647 }
648
649 mouse_event =
650 qemu_put_mouse_event_current->qemu_put_mouse_event;
651 mouse_event_opaque =
652 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
653
654 if (mouse_event) {
655 if (graphic_rotate) {
656 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
657 width = 0x7fff;
658 else
659 width = graphic_width - 1;
660 mouse_event(mouse_event_opaque,
661 width - dy, dx, dz, buttons_state);
662 } else
663 mouse_event(mouse_event_opaque,
664 dx, dy, dz, buttons_state);
665 }
666}
667
668int kbd_mouse_is_absolute(void)
669{
670 if (!qemu_put_mouse_event_current)
671 return 0;
672
673 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
674}
675
676void do_info_mice(Monitor *mon)
677{
678 QEMUPutMouseEntry *cursor;
679 int index = 0;
680
681 if (!qemu_put_mouse_event_head) {
682 monitor_printf(mon, "No mouse devices connected\n");
683 return;
684 }
685
686 monitor_printf(mon, "Mouse devices available:\n");
687 cursor = qemu_put_mouse_event_head;
688 while (cursor != NULL) {
689 monitor_printf(mon, "%c Mouse #%d: %s\n",
690 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
691 index, cursor->qemu_put_mouse_event_name);
692 index++;
693 cursor = cursor->next;
694 }
695}
696
697void do_mouse_set(Monitor *mon, int index)
698{
699 QEMUPutMouseEntry *cursor;
700 int i = 0;
701
702 if (!qemu_put_mouse_event_head) {
703 monitor_printf(mon, "No mouse devices connected\n");
704 return;
705 }
706
707 cursor = qemu_put_mouse_event_head;
708 while (cursor != NULL && index != i) {
709 i++;
710 cursor = cursor->next;
711 }
712
713 if (cursor != NULL)
714 qemu_put_mouse_event_current = cursor;
715 else
716 monitor_printf(mon, "Mouse at given index not found\n");
717}
718
719/* compute with 96 bit intermediate result: (a*b)/c */
720uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
721{
722 union {
723 uint64_t ll;
724 struct {
725#ifdef WORDS_BIGENDIAN
726 uint32_t high, low;
727#else
728 uint32_t low, high;
729#endif
730 } l;
731 } u, res;
732 uint64_t rl, rh;
733
734 u.ll = a;
735 rl = (uint64_t)u.l.low * (uint64_t)b;
736 rh = (uint64_t)u.l.high * (uint64_t)b;
737 rh += (rl >> 32);
738 res.l.high = rh / c;
739 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
740 return res.ll;
741}
742
743/***********************************************************/
744/* real time host monotonic timer */
745
746#define QEMU_TIMER_BASE 1000000000LL
747
748#ifdef WIN32
749
750static int64_t clock_freq;
751
752static void init_get_clock(void)
753{
754 LARGE_INTEGER freq;
755 int ret;
756 ret = QueryPerformanceFrequency(&freq);
757 if (ret == 0) {
758 fprintf(stderr, "Could not calibrate ticks\n");
759 exit(1);
760 }
761 clock_freq = freq.QuadPart;
762}
763
764static int64_t get_clock(void)
765{
766 LARGE_INTEGER ti;
767 QueryPerformanceCounter(&ti);
768 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
769}
770
771#else
772
773static int use_rt_clock;
774
775static void init_get_clock(void)
776{
777 use_rt_clock = 0;
778#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
779 || defined(__DragonFly__)
780 {
781 struct timespec ts;
782 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
783 use_rt_clock = 1;
784 }
785 }
786#endif
787}
788
789static int64_t get_clock(void)
790{
791#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
792 || defined(__DragonFly__)
793 if (use_rt_clock) {
794 struct timespec ts;
795 clock_gettime(CLOCK_MONOTONIC, &ts);
796 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
797 } else
798#endif
799 {
800 /* XXX: using gettimeofday leads to problems if the date
801 changes, so it should be avoided. */
802 struct timeval tv;
803 gettimeofday(&tv, NULL);
804 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
805 }
806}
807#endif
808
809/* Return the virtual CPU time, based on the instruction counter. */
810static int64_t cpu_get_icount(void)
811{
812 int64_t icount;
813 CPUState *env = cpu_single_env;;
814 icount = qemu_icount;
815 if (env) {
816 if (!can_do_io(env))
817 fprintf(stderr, "Bad clock read\n");
818 icount -= (env->icount_decr.u16.low + env->icount_extra);
819 }
820 return qemu_icount_bias + (icount << icount_time_shift);
821}
822
823/***********************************************************/
824/* guest cycle counter */
825
826static int64_t cpu_ticks_prev;
827static int64_t cpu_ticks_offset;
828static int64_t cpu_clock_offset;
829static int cpu_ticks_enabled;
830
831/* return the host CPU cycle counter and handle stop/restart */
832int64_t cpu_get_ticks(void)
833{
834 if (use_icount) {
835 return cpu_get_icount();
836 }
837 if (!cpu_ticks_enabled) {
838 return cpu_ticks_offset;
839 } else {
840 int64_t ticks;
841 ticks = cpu_get_real_ticks();
842 if (cpu_ticks_prev > ticks) {
843 /* Note: non increasing ticks may happen if the host uses
844 software suspend */
845 cpu_ticks_offset += cpu_ticks_prev - ticks;
846 }
847 cpu_ticks_prev = ticks;
848 return ticks + cpu_ticks_offset;
849 }
850}
851
852/* return the host CPU monotonic timer and handle stop/restart */
853static int64_t cpu_get_clock(void)
854{
855 int64_t ti;
856 if (!cpu_ticks_enabled) {
857 return cpu_clock_offset;
858 } else {
859 ti = get_clock();
860 return ti + cpu_clock_offset;
861 }
862}
863
864/* enable cpu_get_ticks() */
865void cpu_enable_ticks(void)
866{
867 if (!cpu_ticks_enabled) {
868 cpu_ticks_offset -= cpu_get_real_ticks();
869 cpu_clock_offset -= get_clock();
870 cpu_ticks_enabled = 1;
871 }
872}
873
874/* disable cpu_get_ticks() : the clock is stopped. You must not call
875 cpu_get_ticks() after that. */
876void cpu_disable_ticks(void)
877{
878 if (cpu_ticks_enabled) {
879 cpu_ticks_offset = cpu_get_ticks();
880 cpu_clock_offset = cpu_get_clock();
881 cpu_ticks_enabled = 0;
882 }
883}
884
885/***********************************************************/
886/* timers */
887
888#define QEMU_TIMER_REALTIME 0
889#define QEMU_TIMER_VIRTUAL 1
890
891struct QEMUClock {
892 int type;
893 /* XXX: add frequency */
894};
895
896struct QEMUTimer {
897 QEMUClock *clock;
898 int64_t expire_time;
899 QEMUTimerCB *cb;
900 void *opaque;
901 struct QEMUTimer *next;
902};
903
904struct qemu_alarm_timer {
905 char const *name;
906 unsigned int flags;
907
908 int (*start)(struct qemu_alarm_timer *t);
909 void (*stop)(struct qemu_alarm_timer *t);
910 void (*rearm)(struct qemu_alarm_timer *t);
911 void *priv;
912};
913
914#define ALARM_FLAG_DYNTICKS 0x1
915#define ALARM_FLAG_EXPIRED 0x2
916
917static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
918{
919 return t && (t->flags & ALARM_FLAG_DYNTICKS);
920}
921
922static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
923{
924 if (!alarm_has_dynticks(t))
925 return;
926
927 t->rearm(t);
928}
929
930/* TODO: MIN_TIMER_REARM_US should be optimized */
931#define MIN_TIMER_REARM_US 250
932
933static struct qemu_alarm_timer *alarm_timer;
934
935#ifdef _WIN32
936
937struct qemu_alarm_win32 {
938 MMRESULT timerId;
939 unsigned int period;
940} alarm_win32_data = {0, -1};
941
942static int win32_start_timer(struct qemu_alarm_timer *t);
943static void win32_stop_timer(struct qemu_alarm_timer *t);
944static void win32_rearm_timer(struct qemu_alarm_timer *t);
945
946#else
947
948static int unix_start_timer(struct qemu_alarm_timer *t);
949static void unix_stop_timer(struct qemu_alarm_timer *t);
950
951#ifdef __linux__
952
953static int dynticks_start_timer(struct qemu_alarm_timer *t);
954static void dynticks_stop_timer(struct qemu_alarm_timer *t);
955static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
956
957static int hpet_start_timer(struct qemu_alarm_timer *t);
958static void hpet_stop_timer(struct qemu_alarm_timer *t);
959
960static int rtc_start_timer(struct qemu_alarm_timer *t);
961static void rtc_stop_timer(struct qemu_alarm_timer *t);
962
963#endif /* __linux__ */
964
965#endif /* _WIN32 */
966
967/* Correlation between real and virtual time is always going to be
968 fairly approximate, so ignore small variation.
969 When the guest is idle real and virtual time will be aligned in
970 the IO wait loop. */
971#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
972
973static void icount_adjust(void)
974{
975 int64_t cur_time;
976 int64_t cur_icount;
977 int64_t delta;
978 static int64_t last_delta;
979 /* If the VM is not running, then do nothing. */
980 if (!vm_running)
981 return;
982
983 cur_time = cpu_get_clock();
984 cur_icount = qemu_get_clock(vm_clock);
985 delta = cur_icount - cur_time;
986 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
987 if (delta > 0
988 && last_delta + ICOUNT_WOBBLE < delta * 2
989 && icount_time_shift > 0) {
990 /* The guest is getting too far ahead. Slow time down. */
991 icount_time_shift--;
992 }
993 if (delta < 0
994 && last_delta - ICOUNT_WOBBLE > delta * 2
995 && icount_time_shift < MAX_ICOUNT_SHIFT) {
996 /* The guest is getting too far behind. Speed time up. */
997 icount_time_shift++;
998 }
999 last_delta = delta;
1000 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
1001}
1002
1003static void icount_adjust_rt(void * opaque)
1004{
1005 qemu_mod_timer(icount_rt_timer,
1006 qemu_get_clock(rt_clock) + 1000);
1007 icount_adjust();
1008}
1009
1010static void icount_adjust_vm(void * opaque)
1011{
1012 qemu_mod_timer(icount_vm_timer,
1013 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1014 icount_adjust();
1015}
1016
1017static void init_icount_adjust(void)
1018{
1019 /* Have both realtime and virtual time triggers for speed adjustment.
1020 The realtime trigger catches emulated time passing too slowly,
1021 the virtual time trigger catches emulated time passing too fast.
1022 Realtime triggers occur even when idle, so use them less frequently
1023 than VM triggers. */
1024 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1025 qemu_mod_timer(icount_rt_timer,
1026 qemu_get_clock(rt_clock) + 1000);
1027 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1028 qemu_mod_timer(icount_vm_timer,
1029 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1030}
1031
1032static struct qemu_alarm_timer alarm_timers[] = {
1033#ifndef _WIN32
1034#ifdef __linux__
1035 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1036 dynticks_stop_timer, dynticks_rearm_timer, NULL},
1037 /* HPET - if available - is preferred */
1038 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1039 /* ...otherwise try RTC */
1040 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1041#endif
1042 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1043#else
1044 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1045 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1046 {"win32", 0, win32_start_timer,
1047 win32_stop_timer, NULL, &alarm_win32_data},
1048#endif
1049 {NULL, }
1050};
1051
1052static void show_available_alarms(void)
1053{
1054 int i;
1055
1056 printf("Available alarm timers, in order of precedence:\n");
1057 for (i = 0; alarm_timers[i].name; i++)
1058 printf("%s\n", alarm_timers[i].name);
1059}
1060
1061static void configure_alarms(char const *opt)
1062{
1063 int i;
1064 int cur = 0;
1065 int count = ARRAY_SIZE(alarm_timers) - 1;
1066 char *arg;
1067 char *name;
1068 struct qemu_alarm_timer tmp;
1069
1070 if (!strcmp(opt, "?")) {
1071 show_available_alarms();
1072 exit(0);
1073 }
1074
1075 arg = strdup(opt);
1076
1077 /* Reorder the array */
1078 name = strtok(arg, ",");
1079 while (name) {
1080 for (i = 0; i < count && alarm_timers[i].name; i++) {
1081 if (!strcmp(alarm_timers[i].name, name))
1082 break;
1083 }
1084
1085 if (i == count) {
1086 fprintf(stderr, "Unknown clock %s\n", name);
1087 goto next;
1088 }
1089
1090 if (i < cur)
1091 /* Ignore */
1092 goto next;
1093
1094 /* Swap */
1095 tmp = alarm_timers[i];
1096 alarm_timers[i] = alarm_timers[cur];
1097 alarm_timers[cur] = tmp;
1098
1099 cur++;
1100next:
1101 name = strtok(NULL, ",");
1102 }
1103
1104 free(arg);
1105
1106 if (cur) {
1107 /* Disable remaining timers */
1108 for (i = cur; i < count; i++)
1109 alarm_timers[i].name = NULL;
1110 } else {
1111 show_available_alarms();
1112 exit(1);
1113 }
1114}
1115
1116QEMUClock *rt_clock;
1117QEMUClock *vm_clock;
1118
1119static QEMUTimer *active_timers[2];
1120
1121static QEMUClock *qemu_new_clock(int type)
1122{
1123 QEMUClock *clock;
1124 clock = qemu_mallocz(sizeof(QEMUClock));
1125 clock->type = type;
1126 return clock;
1127}
1128
1129QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1130{
1131 QEMUTimer *ts;
1132
1133 ts = qemu_mallocz(sizeof(QEMUTimer));
1134 ts->clock = clock;
1135 ts->cb = cb;
1136 ts->opaque = opaque;
1137 return ts;
1138}
1139
1140void qemu_free_timer(QEMUTimer *ts)
1141{
1142 qemu_free(ts);
1143}
1144
1145/* stop a timer, but do not dealloc it */
1146void qemu_del_timer(QEMUTimer *ts)
1147{
1148 QEMUTimer **pt, *t;
1149
1150 /* NOTE: this code must be signal safe because
1151 qemu_timer_expired() can be called from a signal. */
1152 pt = &active_timers[ts->clock->type];
1153 for(;;) {
1154 t = *pt;
1155 if (!t)
1156 break;
1157 if (t == ts) {
1158 *pt = t->next;
1159 break;
1160 }
1161 pt = &t->next;
1162 }
1163}
1164
1165/* modify the current timer so that it will be fired when current_time
1166 >= expire_time. The corresponding callback will be called. */
1167void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1168{
1169 QEMUTimer **pt, *t;
1170
1171 qemu_del_timer(ts);
1172
1173 /* add the timer in the sorted list */
1174 /* NOTE: this code must be signal safe because
1175 qemu_timer_expired() can be called from a signal. */
1176 pt = &active_timers[ts->clock->type];
1177 for(;;) {
1178 t = *pt;
1179 if (!t)
1180 break;
1181 if (t->expire_time > expire_time)
1182 break;
1183 pt = &t->next;
1184 }
1185 ts->expire_time = expire_time;
1186 ts->next = *pt;
1187 *pt = ts;
1188
1189 /* Rearm if necessary */
1190 if (pt == &active_timers[ts->clock->type]) {
1191 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1192 qemu_rearm_alarm_timer(alarm_timer);
1193 }
1194 /* Interrupt execution to force deadline recalculation. */
1195 if (use_icount)
1196 qemu_notify_event();
1197 }
1198}
1199
1200int qemu_timer_pending(QEMUTimer *ts)
1201{
1202 QEMUTimer *t;
1203 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1204 if (t == ts)
1205 return 1;
1206 }
1207 return 0;
1208}
1209
1210static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1211{
1212 if (!timer_head)
1213 return 0;
1214 return (timer_head->expire_time <= current_time);
1215}
1216
1217static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1218{
1219 QEMUTimer *ts;
1220
1221 for(;;) {
1222 ts = *ptimer_head;
1223 if (!ts || ts->expire_time > current_time)
1224 break;
1225 /* remove timer from the list before calling the callback */
1226 *ptimer_head = ts->next;
1227 ts->next = NULL;
1228
1229 /* run the callback (the timer list can be modified) */
1230 ts->cb(ts->opaque);
1231 }
1232}
1233
1234int64_t qemu_get_clock(QEMUClock *clock)
1235{
1236 switch(clock->type) {
1237 case QEMU_TIMER_REALTIME:
1238 return get_clock() / 1000000;
1239 default:
1240 case QEMU_TIMER_VIRTUAL:
1241 if (use_icount) {
1242 return cpu_get_icount();
1243 } else {
1244 return cpu_get_clock();
1245 }
1246 }
1247}
1248
1249static void init_timers(void)
1250{
1251 init_get_clock();
1252 ticks_per_sec = QEMU_TIMER_BASE;
1253 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1254 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1255}
1256
1257/* save a timer */
1258void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1259{
1260 uint64_t expire_time;
1261
1262 if (qemu_timer_pending(ts)) {
1263 expire_time = ts->expire_time;
1264 } else {
1265 expire_time = -1;
1266 }
1267 qemu_put_be64(f, expire_time);
1268}
1269
1270void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1271{
1272 uint64_t expire_time;
1273
1274 expire_time = qemu_get_be64(f);
1275 if (expire_time != -1) {
1276 qemu_mod_timer(ts, expire_time);
1277 } else {
1278 qemu_del_timer(ts);
1279 }
1280}
1281
1282static void timer_save(QEMUFile *f, void *opaque)
1283{
1284 if (cpu_ticks_enabled) {
1285 hw_error("cannot save state if virtual timers are running");
1286 }
1287 qemu_put_be64(f, cpu_ticks_offset);
1288 qemu_put_be64(f, ticks_per_sec);
1289 qemu_put_be64(f, cpu_clock_offset);
1290}
1291
1292static int timer_load(QEMUFile *f, void *opaque, int version_id)
1293{
1294 if (version_id != 1 && version_id != 2)
1295 return -EINVAL;
1296 if (cpu_ticks_enabled) {
1297 return -EINVAL;
1298 }
1299 cpu_ticks_offset=qemu_get_be64(f);
1300 ticks_per_sec=qemu_get_be64(f);
1301 if (version_id == 2) {
1302 cpu_clock_offset=qemu_get_be64(f);
1303 }
1304 return 0;
1305}
1306
1307static void qemu_event_increment(void);
1308
1309#ifdef _WIN32
1310static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1311 DWORD_PTR dwUser, DWORD_PTR dw1,
1312 DWORD_PTR dw2)
1313#else
1314static void host_alarm_handler(int host_signum)
1315#endif
1316{
1317#if 0
1318#define DISP_FREQ 1000
1319 {
1320 static int64_t delta_min = INT64_MAX;
1321 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1322 static int count;
1323 ti = qemu_get_clock(vm_clock);
1324 if (last_clock != 0) {
1325 delta = ti - last_clock;
1326 if (delta < delta_min)
1327 delta_min = delta;
1328 if (delta > delta_max)
1329 delta_max = delta;
1330 delta_cum += delta;
1331 if (++count == DISP_FREQ) {
1332 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1333 muldiv64(delta_min, 1000000, ticks_per_sec),
1334 muldiv64(delta_max, 1000000, ticks_per_sec),
1335 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1336 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1337 count = 0;
1338 delta_min = INT64_MAX;
1339 delta_max = 0;
1340 delta_cum = 0;
1341 }
1342 }
1343 last_clock = ti;
1344 }
1345#endif
1346 if (alarm_has_dynticks(alarm_timer) ||
1347 (!use_icount &&
1348 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1349 qemu_get_clock(vm_clock))) ||
1350 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1351 qemu_get_clock(rt_clock))) {
1352 qemu_event_increment();
1353 if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1354
1355#ifndef CONFIG_IOTHREAD
1356 if (next_cpu) {
1357 /* stop the currently executing cpu because a timer occured */
1358 cpu_exit(next_cpu);
1359#ifdef CONFIG_KQEMU
1360 if (next_cpu->kqemu_enabled) {
1361 kqemu_cpu_interrupt(next_cpu);
1362 }
1363#endif
1364 }
1365#endif
1366 timer_alarm_pending = 1;
1367 qemu_notify_event();
1368 }
1369}
1370
1371static int64_t qemu_next_deadline(void)
1372{
1373 int64_t delta;
1374
1375 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1376 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1377 qemu_get_clock(vm_clock);
1378 } else {
1379 /* To avoid problems with overflow limit this to 2^32. */
1380 delta = INT32_MAX;
1381 }
1382
1383 if (delta < 0)
1384 delta = 0;
1385
1386 return delta;
1387}
1388
1389#if defined(__linux__) || defined(_WIN32)
1390static uint64_t qemu_next_deadline_dyntick(void)
1391{
1392 int64_t delta;
1393 int64_t rtdelta;
1394
1395 if (use_icount)
1396 delta = INT32_MAX;
1397 else
1398 delta = (qemu_next_deadline() + 999) / 1000;
1399
1400 if (active_timers[QEMU_TIMER_REALTIME]) {
1401 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1402 qemu_get_clock(rt_clock))*1000;
1403 if (rtdelta < delta)
1404 delta = rtdelta;
1405 }
1406
1407 if (delta < MIN_TIMER_REARM_US)
1408 delta = MIN_TIMER_REARM_US;
1409
1410 return delta;
1411}
1412#endif
1413
1414#ifndef _WIN32
1415
1416/* Sets a specific flag */
1417static int fcntl_setfl(int fd, int flag)
1418{
1419 int flags;
1420
1421 flags = fcntl(fd, F_GETFL);
1422 if (flags == -1)
1423 return -errno;
1424
1425 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1426 return -errno;
1427
1428 return 0;
1429}
1430
1431#if defined(__linux__)
1432
1433#define RTC_FREQ 1024
1434
1435static void enable_sigio_timer(int fd)
1436{
1437 struct sigaction act;
1438
1439 /* timer signal */
1440 sigfillset(&act.sa_mask);
1441 act.sa_flags = 0;
1442 act.sa_handler = host_alarm_handler;
1443
1444 sigaction(SIGIO, &act, NULL);
1445 fcntl_setfl(fd, O_ASYNC);
1446 fcntl(fd, F_SETOWN, getpid());
1447}
1448
1449static int hpet_start_timer(struct qemu_alarm_timer *t)
1450{
1451 struct hpet_info info;
1452 int r, fd;
1453
1454 fd = open("/dev/hpet", O_RDONLY);
1455 if (fd < 0)
1456 return -1;
1457
1458 /* Set frequency */
1459 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1460 if (r < 0) {
1461 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1462 "error, but for better emulation accuracy type:\n"
1463 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1464 goto fail;
1465 }
1466
1467 /* Check capabilities */
1468 r = ioctl(fd, HPET_INFO, &info);
1469 if (r < 0)
1470 goto fail;
1471
1472 /* Enable periodic mode */
1473 r = ioctl(fd, HPET_EPI, 0);
1474 if (info.hi_flags && (r < 0))
1475 goto fail;
1476
1477 /* Enable interrupt */
1478 r = ioctl(fd, HPET_IE_ON, 0);
1479 if (r < 0)
1480 goto fail;
1481
1482 enable_sigio_timer(fd);
1483 t->priv = (void *)(long)fd;
1484
1485 return 0;
1486fail:
1487 close(fd);
1488 return -1;
1489}
1490
1491static void hpet_stop_timer(struct qemu_alarm_timer *t)
1492{
1493 int fd = (long)t->priv;
1494
1495 close(fd);
1496}
1497
1498static int rtc_start_timer(struct qemu_alarm_timer *t)
1499{
1500 int rtc_fd;
1501 unsigned long current_rtc_freq = 0;
1502
1503 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1504 if (rtc_fd < 0)
1505 return -1;
1506 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1507 if (current_rtc_freq != RTC_FREQ &&
1508 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1509 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1510 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1511 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1512 goto fail;
1513 }
1514 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1515 fail:
1516 close(rtc_fd);
1517 return -1;
1518 }
1519
1520 enable_sigio_timer(rtc_fd);
1521
1522 t->priv = (void *)(long)rtc_fd;
1523
1524 return 0;
1525}
1526
1527static void rtc_stop_timer(struct qemu_alarm_timer *t)
1528{
1529 int rtc_fd = (long)t->priv;
1530
1531 close(rtc_fd);
1532}
1533
1534static int dynticks_start_timer(struct qemu_alarm_timer *t)
1535{
1536 struct sigevent ev;
1537 timer_t host_timer;
1538 struct sigaction act;
1539
1540 sigfillset(&act.sa_mask);
1541 act.sa_flags = 0;
1542 act.sa_handler = host_alarm_handler;
1543
1544 sigaction(SIGALRM, &act, NULL);
1545
1546 /*
1547 * Initialize ev struct to 0 to avoid valgrind complaining
1548 * about uninitialized data in timer_create call
1549 */
1550 memset(&ev, 0, sizeof(ev));
1551 ev.sigev_value.sival_int = 0;
1552 ev.sigev_notify = SIGEV_SIGNAL;
1553 ev.sigev_signo = SIGALRM;
1554
1555 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1556 perror("timer_create");
1557
1558 /* disable dynticks */
1559 fprintf(stderr, "Dynamic Ticks disabled\n");
1560
1561 return -1;
1562 }
1563
1564 t->priv = (void *)(long)host_timer;
1565
1566 return 0;
1567}
1568
1569static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1570{
1571 timer_t host_timer = (timer_t)(long)t->priv;
1572
1573 timer_delete(host_timer);
1574}
1575
1576static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1577{
1578 timer_t host_timer = (timer_t)(long)t->priv;
1579 struct itimerspec timeout;
1580 int64_t nearest_delta_us = INT64_MAX;
1581 int64_t current_us;
1582
1583 if (!active_timers[QEMU_TIMER_REALTIME] &&
1584 !active_timers[QEMU_TIMER_VIRTUAL])
1585 return;
1586
1587 nearest_delta_us = qemu_next_deadline_dyntick();
1588
1589 /* check whether a timer is already running */
1590 if (timer_gettime(host_timer, &timeout)) {
1591 perror("gettime");
1592 fprintf(stderr, "Internal timer error: aborting\n");
1593 exit(1);
1594 }
1595 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1596 if (current_us && current_us <= nearest_delta_us)
1597 return;
1598
1599 timeout.it_interval.tv_sec = 0;
1600 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1601 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1602 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1603 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1604 perror("settime");
1605 fprintf(stderr, "Internal timer error: aborting\n");
1606 exit(1);
1607 }
1608}
1609
1610#endif /* defined(__linux__) */
1611
1612static int unix_start_timer(struct qemu_alarm_timer *t)
1613{
1614 struct sigaction act;
1615 struct itimerval itv;
1616 int err;
1617
1618 /* timer signal */
1619 sigfillset(&act.sa_mask);
1620 act.sa_flags = 0;
1621 act.sa_handler = host_alarm_handler;
1622
1623 sigaction(SIGALRM, &act, NULL);
1624
1625 itv.it_interval.tv_sec = 0;
1626 /* for i386 kernel 2.6 to get 1 ms */
1627 itv.it_interval.tv_usec = 999;
1628 itv.it_value.tv_sec = 0;
1629 itv.it_value.tv_usec = 10 * 1000;
1630
1631 err = setitimer(ITIMER_REAL, &itv, NULL);
1632 if (err)
1633 return -1;
1634
1635 return 0;
1636}
1637
1638static void unix_stop_timer(struct qemu_alarm_timer *t)
1639{
1640 struct itimerval itv;
1641
1642 memset(&itv, 0, sizeof(itv));
1643 setitimer(ITIMER_REAL, &itv, NULL);
1644}
1645
1646#endif /* !defined(_WIN32) */
1647
1648
1649#ifdef _WIN32
1650
1651static int win32_start_timer(struct qemu_alarm_timer *t)
1652{
1653 TIMECAPS tc;
1654 struct qemu_alarm_win32 *data = t->priv;
1655 UINT flags;
1656
1657 memset(&tc, 0, sizeof(tc));
1658 timeGetDevCaps(&tc, sizeof(tc));
1659
1660 if (data->period < tc.wPeriodMin)
1661 data->period = tc.wPeriodMin;
1662
1663 timeBeginPeriod(data->period);
1664
1665 flags = TIME_CALLBACK_FUNCTION;
1666 if (alarm_has_dynticks(t))
1667 flags |= TIME_ONESHOT;
1668 else
1669 flags |= TIME_PERIODIC;
1670
1671 data->timerId = timeSetEvent(1, // interval (ms)
1672 data->period, // resolution
1673 host_alarm_handler, // function
1674 (DWORD)t, // parameter
1675 flags);
1676
1677 if (!data->timerId) {
1678 perror("Failed to initialize win32 alarm timer");
1679 timeEndPeriod(data->period);
1680 return -1;
1681 }
1682
1683 return 0;
1684}
1685
1686static void win32_stop_timer(struct qemu_alarm_timer *t)
1687{
1688 struct qemu_alarm_win32 *data = t->priv;
1689
1690 timeKillEvent(data->timerId);
1691 timeEndPeriod(data->period);
1692}
1693
1694static void win32_rearm_timer(struct qemu_alarm_timer *t)
1695{
1696 struct qemu_alarm_win32 *data = t->priv;
1697 uint64_t nearest_delta_us;
1698
1699 if (!active_timers[QEMU_TIMER_REALTIME] &&
1700 !active_timers[QEMU_TIMER_VIRTUAL])
1701 return;
1702
1703 nearest_delta_us = qemu_next_deadline_dyntick();
1704 nearest_delta_us /= 1000;
1705
1706 timeKillEvent(data->timerId);
1707
1708 data->timerId = timeSetEvent(1,
1709 data->period,
1710 host_alarm_handler,
1711 (DWORD)t,
1712 TIME_ONESHOT | TIME_PERIODIC);
1713
1714 if (!data->timerId) {
1715 perror("Failed to re-arm win32 alarm timer");
1716
1717 timeEndPeriod(data->period);
1718 exit(1);
1719 }
1720}
1721
1722#endif /* _WIN32 */
1723
1724static int init_timer_alarm(void)
1725{
1726 struct qemu_alarm_timer *t = NULL;
1727 int i, err = -1;
1728
1729 for (i = 0; alarm_timers[i].name; i++) {
1730 t = &alarm_timers[i];
1731
1732 err = t->start(t);
1733 if (!err)
1734 break;
1735 }
1736
1737 if (err) {
1738 err = -ENOENT;
1739 goto fail;
1740 }
1741
1742 alarm_timer = t;
1743
1744 return 0;
1745
1746fail:
1747 return err;
1748}
1749
1750static void quit_timers(void)
1751{
1752 alarm_timer->stop(alarm_timer);
1753 alarm_timer = NULL;
1754}
1755
1756/***********************************************************/
1757/* host time/date access */
1758void qemu_get_timedate(struct tm *tm, int offset)
1759{
1760 time_t ti;
1761 struct tm *ret;
1762
1763 time(&ti);
1764 ti += offset;
1765 if (rtc_date_offset == -1) {
1766 if (rtc_utc)
1767 ret = gmtime(&ti);
1768 else
1769 ret = localtime(&ti);
1770 } else {
1771 ti -= rtc_date_offset;
1772 ret = gmtime(&ti);
1773 }
1774
1775 memcpy(tm, ret, sizeof(struct tm));
1776}
1777
1778int qemu_timedate_diff(struct tm *tm)
1779{
1780 time_t seconds;
1781
1782 if (rtc_date_offset == -1)
1783 if (rtc_utc)
1784 seconds = mktimegm(tm);
1785 else
1786 seconds = mktime(tm);
1787 else
1788 seconds = mktimegm(tm) + rtc_date_offset;
1789
1790 return seconds - time(NULL);
1791}
1792
1793#ifdef _WIN32
1794static void socket_cleanup(void)
1795{
1796 WSACleanup();
1797}
1798
1799static int socket_init(void)
1800{
1801 WSADATA Data;
1802 int ret, err;
1803
1804 ret = WSAStartup(MAKEWORD(2,2), &Data);
1805 if (ret != 0) {
1806 err = WSAGetLastError();
1807 fprintf(stderr, "WSAStartup: %d\n", err);
1808 return -1;
1809 }
1810 atexit(socket_cleanup);
1811 return 0;
1812}
1813#endif
1814
1815int get_param_value(char *buf, int buf_size,
1816 const char *tag, const char *str)
1817{
1818 const char *p;
1819 char option[128];
1820
1821 p = str;
1822 for(;;) {
1823 p = get_opt_name(option, sizeof(option), p, '=');
1824 if (*p != '=')
1825 break;
1826 p++;
1827 if (!strcmp(tag, option)) {
1828 (void)get_opt_value(buf, buf_size, p);
1829 return strlen(buf);
1830 } else {
1831 p = get_opt_value(NULL, 0, p);
1832 }
1833 if (*p != ',')
1834 break;
1835 p++;
1836 }
1837 return 0;
1838}
1839
1840int check_params(char *buf, int buf_size,
1841 const char * const *params, const char *str)
1842{
1843 const char *p;
1844 int i;
1845
1846 p = str;
1847 while (*p != '\0') {
1848 p = get_opt_name(buf, buf_size, p, '=');
1849 if (*p != '=') {
1850 return -1;
1851 }
1852 p++;
1853 for (i = 0; params[i] != NULL; i++) {
1854 if (!strcmp(params[i], buf)) {
1855 break;
1856 }
1857 }
1858 if (params[i] == NULL) {
1859 return -1;
1860 }
1861 p = get_opt_value(NULL, 0, p);
1862 if (*p != ',') {
1863 break;
1864 }
1865 p++;
1866 }
1867 return 0;
1868}
1869
1870/***********************************************************/
1871/* Bluetooth support */
1872static int nb_hcis;
1873static int cur_hci;
1874static struct HCIInfo *hci_table[MAX_NICS];
1875
1876static struct bt_vlan_s {
1877 struct bt_scatternet_s net;
1878 int id;
1879 struct bt_vlan_s *next;
1880} *first_bt_vlan;
1881
1882/* find or alloc a new bluetooth "VLAN" */
1883static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1884{
1885 struct bt_vlan_s **pvlan, *vlan;
1886 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1887 if (vlan->id == id)
1888 return &vlan->net;
1889 }
1890 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1891 vlan->id = id;
1892 pvlan = &first_bt_vlan;
1893 while (*pvlan != NULL)
1894 pvlan = &(*pvlan)->next;
1895 *pvlan = vlan;
1896 return &vlan->net;
1897}
1898
1899static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1900{
1901}
1902
1903static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1904{
1905 return -ENOTSUP;
1906}
1907
1908static struct HCIInfo null_hci = {
1909 .cmd_send = null_hci_send,
1910 .sco_send = null_hci_send,
1911 .acl_send = null_hci_send,
1912 .bdaddr_set = null_hci_addr_set,
1913};
1914
1915struct HCIInfo *qemu_next_hci(void)
1916{
1917 if (cur_hci == nb_hcis)
1918 return &null_hci;
1919
1920 return hci_table[cur_hci++];
1921}
1922
1923static struct HCIInfo *hci_init(const char *str)
1924{
1925 char *endp;
1926 struct bt_scatternet_s *vlan = 0;
1927
1928 if (!strcmp(str, "null"))
1929 /* null */
1930 return &null_hci;
1931 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1932 /* host[:hciN] */
1933 return bt_host_hci(str[4] ? str + 5 : "hci0");
1934 else if (!strncmp(str, "hci", 3)) {
1935 /* hci[,vlan=n] */
1936 if (str[3]) {
1937 if (!strncmp(str + 3, ",vlan=", 6)) {
1938 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1939 if (*endp)
1940 vlan = 0;
1941 }
1942 } else
1943 vlan = qemu_find_bt_vlan(0);
1944 if (vlan)
1945 return bt_new_hci(vlan);
1946 }
1947
1948 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1949
1950 return 0;
1951}
1952
1953static int bt_hci_parse(const char *str)
1954{
1955 struct HCIInfo *hci;
1956 bdaddr_t bdaddr;
1957
1958 if (nb_hcis >= MAX_NICS) {
1959 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1960 return -1;
1961 }
1962
1963 hci = hci_init(str);
1964 if (!hci)
1965 return -1;
1966
1967 bdaddr.b[0] = 0x52;
1968 bdaddr.b[1] = 0x54;
1969 bdaddr.b[2] = 0x00;
1970 bdaddr.b[3] = 0x12;
1971 bdaddr.b[4] = 0x34;
1972 bdaddr.b[5] = 0x56 + nb_hcis;
1973 hci->bdaddr_set(hci, bdaddr.b);
1974
1975 hci_table[nb_hcis++] = hci;
1976
1977 return 0;
1978}
1979
1980static void bt_vhci_add(int vlan_id)
1981{
1982 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1983
1984 if (!vlan->slave)
1985 fprintf(stderr, "qemu: warning: adding a VHCI to "
1986 "an empty scatternet %i\n", vlan_id);
1987
1988 bt_vhci_init(bt_new_hci(vlan));
1989}
1990
1991static struct bt_device_s *bt_device_add(const char *opt)
1992{
1993 struct bt_scatternet_s *vlan;
1994 int vlan_id = 0;
1995 char *endp = strstr(opt, ",vlan=");
1996 int len = (endp ? endp - opt : strlen(opt)) + 1;
1997 char devname[10];
1998
1999 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2000
2001 if (endp) {
2002 vlan_id = strtol(endp + 6, &endp, 0);
2003 if (*endp) {
2004 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2005 return 0;
2006 }
2007 }
2008
2009 vlan = qemu_find_bt_vlan(vlan_id);
2010
2011 if (!vlan->slave)
2012 fprintf(stderr, "qemu: warning: adding a slave device to "
2013 "an empty scatternet %i\n", vlan_id);
2014
2015 if (!strcmp(devname, "keyboard"))
2016 return bt_keyboard_init(vlan);
2017
2018 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2019 return 0;
2020}
2021
2022static int bt_parse(const char *opt)
2023{
2024 const char *endp, *p;
2025 int vlan;
2026
2027 if (strstart(opt, "hci", &endp)) {
2028 if (!*endp || *endp == ',') {
2029 if (*endp)
2030 if (!strstart(endp, ",vlan=", 0))
2031 opt = endp + 1;
2032
2033 return bt_hci_parse(opt);
2034 }
2035 } else if (strstart(opt, "vhci", &endp)) {
2036 if (!*endp || *endp == ',') {
2037 if (*endp) {
2038 if (strstart(endp, ",vlan=", &p)) {
2039 vlan = strtol(p, (char **) &endp, 0);
2040 if (*endp) {
2041 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2042 return 1;
2043 }
2044 } else {
2045 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2046 return 1;
2047 }
2048 } else
2049 vlan = 0;
2050
2051 bt_vhci_add(vlan);
2052 return 0;
2053 }
2054 } else if (strstart(opt, "device:", &endp))
2055 return !bt_device_add(endp);
2056
2057 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2058 return 1;
2059}
2060
2061/***********************************************************/
2062/* QEMU Block devices */
2063
2064#define HD_ALIAS "index=%d,media=disk"
2065#define CDROM_ALIAS "index=2,media=cdrom"
2066#define FD_ALIAS "index=%d,if=floppy"
2067#define PFLASH_ALIAS "if=pflash"
2068#define MTD_ALIAS "if=mtd"
2069#define SD_ALIAS "index=0,if=sd"
2070
2071static int drive_opt_get_free_idx(void)
2072{
2073 int index;
2074
2075 for (index = 0; index < MAX_DRIVES; index++)
2076 if (!drives_opt[index].used) {
2077 drives_opt[index].used = 1;
2078 return index;
2079 }
2080
2081 return -1;
2082}
2083
2084static int drive_get_free_idx(void)
2085{
2086 int index;
2087
2088 for (index = 0; index < MAX_DRIVES; index++)
2089 if (!drives_table[index].used) {
2090 drives_table[index].used = 1;
2091 return index;
2092 }
2093
2094 return -1;
2095}
2096
2097int drive_add(const char *file, const char *fmt, ...)
2098{
2099 va_list ap;
2100 int index = drive_opt_get_free_idx();
2101
2102 if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2103 fprintf(stderr, "qemu: too many drives\n");
2104 return -1;
2105 }
2106
2107 drives_opt[index].file = file;
2108 va_start(ap, fmt);
2109 vsnprintf(drives_opt[index].opt,
2110 sizeof(drives_opt[0].opt), fmt, ap);
2111 va_end(ap);
2112
2113 nb_drives_opt++;
2114 return index;
2115}
2116
2117void drive_remove(int index)
2118{
2119 drives_opt[index].used = 0;
2120 nb_drives_opt--;
2121}
2122
2123int drive_get_index(BlockInterfaceType type, int bus, int unit)
2124{
2125 int index;
2126
2127 /* seek interface, bus and unit */
2128
2129 for (index = 0; index < MAX_DRIVES; index++)
2130 if (drives_table[index].type == type &&
2131 drives_table[index].bus == bus &&
2132 drives_table[index].unit == unit &&
2133 drives_table[index].used)
2134 return index;
2135
2136 return -1;
2137}
2138
2139int drive_get_max_bus(BlockInterfaceType type)
2140{
2141 int max_bus;
2142 int index;
2143
2144 max_bus = -1;
2145 for (index = 0; index < nb_drives; index++) {
2146 if(drives_table[index].type == type &&
2147 drives_table[index].bus > max_bus)
2148 max_bus = drives_table[index].bus;
2149 }
2150 return max_bus;
2151}
2152
2153const char *drive_get_serial(BlockDriverState *bdrv)
2154{
2155 int index;
2156
2157 for (index = 0; index < nb_drives; index++)
2158 if (drives_table[index].bdrv == bdrv)
2159 return drives_table[index].serial;
2160
2161 return "\0";
2162}
2163
2164BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2165{
2166 int index;
2167
2168 for (index = 0; index < nb_drives; index++)
2169 if (drives_table[index].bdrv == bdrv)
2170 return drives_table[index].onerror;
2171
2172 return BLOCK_ERR_STOP_ENOSPC;
2173}
2174
2175static void bdrv_format_print(void *opaque, const char *name)
2176{
2177 fprintf(stderr, " %s", name);
2178}
2179
2180void drive_uninit(BlockDriverState *bdrv)
2181{
2182 int i;
2183
2184 for (i = 0; i < MAX_DRIVES; i++)
2185 if (drives_table[i].bdrv == bdrv) {
2186 drives_table[i].bdrv = NULL;
2187 drives_table[i].used = 0;
2188 drive_remove(drives_table[i].drive_opt_idx);
2189 nb_drives--;
2190 break;
2191 }
2192}
2193
2194int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
2195{
2196 char buf[128];
2197 char file[1024];
2198 char devname[128];
2199 char serial[21];
2200 const char *mediastr = "";
2201 BlockInterfaceType type;
2202 enum { MEDIA_DISK, MEDIA_CDROM } media;
2203 int bus_id, unit_id;
2204 int cyls, heads, secs, translation;
2205 BlockDriverState *bdrv;
2206 BlockDriver *drv = NULL;
2207 QEMUMachine *machine = opaque;
2208 int max_devs;
2209 int index;
2210 int cache;
2211 int bdrv_flags, onerror;
2212 const char *devaddr;
2213 int drives_table_idx;
2214 char *str = arg->opt;
2215 static const char * const params[] = { "bus", "unit", "if", "index",
2216 "cyls", "heads", "secs", "trans",
2217 "media", "snapshot", "file",
2218 "cache", "format", "serial",
2219 "werror", "addr",
2220 NULL };
2221
2222 if (check_params(buf, sizeof(buf), params, str) < 0) {
2223 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2224 buf, str);
2225 return -1;
2226 }
2227
2228 file[0] = 0;
2229 cyls = heads = secs = 0;
2230 bus_id = 0;
2231 unit_id = -1;
2232 translation = BIOS_ATA_TRANSLATION_AUTO;
2233 index = -1;
2234 cache = 3;
2235
2236 if (machine->use_scsi) {
2237 type = IF_SCSI;
2238 max_devs = MAX_SCSI_DEVS;
2239 pstrcpy(devname, sizeof(devname), "scsi");
2240 } else {
2241 type = IF_IDE;
2242 max_devs = MAX_IDE_DEVS;
2243 pstrcpy(devname, sizeof(devname), "ide");
2244 }
2245 media = MEDIA_DISK;
2246
2247 /* extract parameters */
2248
2249 if (get_param_value(buf, sizeof(buf), "bus", str)) {
2250 bus_id = strtol(buf, NULL, 0);
2251 if (bus_id < 0) {
2252 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2253 return -1;
2254 }
2255 }
2256
2257 if (get_param_value(buf, sizeof(buf), "unit", str)) {
2258 unit_id = strtol(buf, NULL, 0);
2259 if (unit_id < 0) {
2260 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2261 return -1;
2262 }
2263 }
2264
2265 if (get_param_value(buf, sizeof(buf), "if", str)) {
2266 pstrcpy(devname, sizeof(devname), buf);
2267 if (!strcmp(buf, "ide")) {
2268 type = IF_IDE;
2269 max_devs = MAX_IDE_DEVS;
2270 } else if (!strcmp(buf, "scsi")) {
2271 type = IF_SCSI;
2272 max_devs = MAX_SCSI_DEVS;
2273 } else if (!strcmp(buf, "floppy")) {
2274 type = IF_FLOPPY;
2275 max_devs = 0;
2276 } else if (!strcmp(buf, "pflash")) {
2277 type = IF_PFLASH;
2278 max_devs = 0;
2279 } else if (!strcmp(buf, "mtd")) {
2280 type = IF_MTD;
2281 max_devs = 0;
2282 } else if (!strcmp(buf, "sd")) {
2283 type = IF_SD;
2284 max_devs = 0;
2285 } else if (!strcmp(buf, "virtio")) {
2286 type = IF_VIRTIO;
2287 max_devs = 0;
2288 } else if (!strcmp(buf, "xen")) {
2289 type = IF_XEN;
2290 max_devs = 0;
2291 } else {
2292 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2293 return -1;
2294 }
2295 }
2296
2297 if (get_param_value(buf, sizeof(buf), "index", str)) {
2298 index = strtol(buf, NULL, 0);
2299 if (index < 0) {
2300 fprintf(stderr, "qemu: '%s' invalid index\n", str);
2301 return -1;
2302 }
2303 }
2304
2305 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2306 cyls = strtol(buf, NULL, 0);
2307 }
2308
2309 if (get_param_value(buf, sizeof(buf), "heads", str)) {
2310 heads = strtol(buf, NULL, 0);
2311 }
2312
2313 if (get_param_value(buf, sizeof(buf), "secs", str)) {
2314 secs = strtol(buf, NULL, 0);
2315 }
2316
2317 if (cyls || heads || secs) {
2318 if (cyls < 1 || cyls > 16383) {
2319 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2320 return -1;
2321 }
2322 if (heads < 1 || heads > 16) {
2323 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2324 return -1;
2325 }
2326 if (secs < 1 || secs > 63) {
2327 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2328 return -1;
2329 }
2330 }
2331
2332 if (get_param_value(buf, sizeof(buf), "trans", str)) {
2333 if (!cyls) {
2334 fprintf(stderr,
2335 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2336 str);
2337 return -1;
2338 }
2339 if (!strcmp(buf, "none"))
2340 translation = BIOS_ATA_TRANSLATION_NONE;
2341 else if (!strcmp(buf, "lba"))
2342 translation = BIOS_ATA_TRANSLATION_LBA;
2343 else if (!strcmp(buf, "auto"))
2344 translation = BIOS_ATA_TRANSLATION_AUTO;
2345 else {
2346 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2347 return -1;
2348 }
2349 }
2350
2351 if (get_param_value(buf, sizeof(buf), "media", str)) {
2352 if (!strcmp(buf, "disk")) {
2353 media = MEDIA_DISK;
2354 } else if (!strcmp(buf, "cdrom")) {
2355 if (cyls || secs || heads) {
2356 fprintf(stderr,
2357 "qemu: '%s' invalid physical CHS format\n", str);
2358 return -1;
2359 }
2360 media = MEDIA_CDROM;
2361 } else {
2362 fprintf(stderr, "qemu: '%s' invalid media\n", str);
2363 return -1;
2364 }
2365 }
2366
2367 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2368 if (!strcmp(buf, "on"))
2369 snapshot = 1;
2370 else if (!strcmp(buf, "off"))
2371 snapshot = 0;
2372 else {
2373 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2374 return -1;
2375 }
2376 }
2377
2378 if (get_param_value(buf, sizeof(buf), "cache", str)) {
2379 if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2380 cache = 0;
2381 else if (!strcmp(buf, "writethrough"))
2382 cache = 1;
2383 else if (!strcmp(buf, "writeback"))
2384 cache = 2;
2385 else {
2386 fprintf(stderr, "qemu: invalid cache option\n");
2387 return -1;
2388 }
2389 }
2390
2391 if (get_param_value(buf, sizeof(buf), "format", str)) {
2392 if (strcmp(buf, "?") == 0) {
2393 fprintf(stderr, "qemu: Supported formats:");
2394 bdrv_iterate_format(bdrv_format_print, NULL);
2395 fprintf(stderr, "\n");
2396 return -1;
2397 }
2398 drv = bdrv_find_format(buf);
2399 if (!drv) {
2400 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2401 return -1;
2402 }
2403 }
2404
2405 if (arg->file == NULL)
2406 get_param_value(file, sizeof(file), "file", str);
2407 else
2408 pstrcpy(file, sizeof(file), arg->file);
2409
2410 if (!get_param_value(serial, sizeof(serial), "serial", str))
2411 memset(serial, 0, sizeof(serial));
2412
2413 onerror = BLOCK_ERR_STOP_ENOSPC;
2414 if (get_param_value(buf, sizeof(serial), "werror", str)) {
2415 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2416 fprintf(stderr, "werror is no supported by this format\n");
2417 return -1;
2418 }
2419 if (!strcmp(buf, "ignore"))
2420 onerror = BLOCK_ERR_IGNORE;
2421 else if (!strcmp(buf, "enospc"))
2422 onerror = BLOCK_ERR_STOP_ENOSPC;
2423 else if (!strcmp(buf, "stop"))
2424 onerror = BLOCK_ERR_STOP_ANY;
2425 else if (!strcmp(buf, "report"))
2426 onerror = BLOCK_ERR_REPORT;
2427 else {
2428 fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2429 return -1;
2430 }
2431 }
2432
2433 devaddr = NULL;
2434 if (get_param_value(buf, sizeof(buf), "addr", str)) {
2435 if (type != IF_VIRTIO) {
2436 fprintf(stderr, "addr is not supported by in '%s'\n", str);
2437 return -1;
2438 }
2439 devaddr = strdup(buf);
2440 }
2441
2442 /* compute bus and unit according index */
2443
2444 if (index != -1) {
2445 if (bus_id != 0 || unit_id != -1) {
2446 fprintf(stderr,
2447 "qemu: '%s' index cannot be used with bus and unit\n", str);
2448 return -1;
2449 }
2450 if (max_devs == 0)
2451 {
2452 unit_id = index;
2453 bus_id = 0;
2454 } else {
2455 unit_id = index % max_devs;
2456 bus_id = index / max_devs;
2457 }
2458 }
2459
2460 /* if user doesn't specify a unit_id,
2461 * try to find the first free
2462 */
2463
2464 if (unit_id == -1) {
2465 unit_id = 0;
2466 while (drive_get_index(type, bus_id, unit_id) != -1) {
2467 unit_id++;
2468 if (max_devs && unit_id >= max_devs) {
2469 unit_id -= max_devs;
2470 bus_id++;
2471 }
2472 }
2473 }
2474
2475 /* check unit id */
2476
2477 if (max_devs && unit_id >= max_devs) {
2478 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2479 str, unit_id, max_devs - 1);
2480 return -1;
2481 }
2482
2483 /*
2484 * ignore multiple definitions
2485 */
2486
2487 if (drive_get_index(type, bus_id, unit_id) != -1)
2488 return -2;
2489
2490 /* init */
2491
2492 if (type == IF_IDE || type == IF_SCSI)
2493 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2494 if (max_devs)
2495 snprintf(buf, sizeof(buf), "%s%i%s%i",
2496 devname, bus_id, mediastr, unit_id);
2497 else
2498 snprintf(buf, sizeof(buf), "%s%s%i",
2499 devname, mediastr, unit_id);
2500 bdrv = bdrv_new(buf);
2501 drives_table_idx = drive_get_free_idx();
2502 drives_table[drives_table_idx].bdrv = bdrv;
2503 drives_table[drives_table_idx].devaddr = devaddr;
2504 drives_table[drives_table_idx].type = type;
2505 drives_table[drives_table_idx].bus = bus_id;
2506 drives_table[drives_table_idx].unit = unit_id;
2507 drives_table[drives_table_idx].onerror = onerror;
2508 drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2509 strncpy(drives_table[drives_table_idx].serial, serial, sizeof(serial));
2510 nb_drives++;
2511
2512 switch(type) {
2513 case IF_IDE:
2514 case IF_SCSI:
2515 case IF_XEN:
2516 switch(media) {
2517 case MEDIA_DISK:
2518 if (cyls != 0) {
2519 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2520 bdrv_set_translation_hint(bdrv, translation);
2521 }
2522 break;
2523 case MEDIA_CDROM:
2524 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2525 break;
2526 }
2527 break;
2528 case IF_SD:
2529 /* FIXME: This isn't really a floppy, but it's a reasonable
2530 approximation. */
2531 case IF_FLOPPY:
2532 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2533 break;
2534 case IF_PFLASH:
2535 case IF_MTD:
2536 case IF_VIRTIO:
2537 break;
2538 case IF_COUNT:
2539 abort();
2540 }
2541 if (!file[0])
2542 return -2;
2543 bdrv_flags = 0;
2544 if (snapshot) {
2545 bdrv_flags |= BDRV_O_SNAPSHOT;
2546 cache = 2; /* always use write-back with snapshot */
2547 }
2548 if (cache == 0) /* no caching */
2549 bdrv_flags |= BDRV_O_NOCACHE;
2550 else if (cache == 2) /* write-back */
2551 bdrv_flags |= BDRV_O_CACHE_WB;
2552 else if (cache == 3) /* not specified */
2553 bdrv_flags |= BDRV_O_CACHE_DEF;
2554 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
2555 fprintf(stderr, "qemu: could not open disk image %s\n",
2556 file);
2557 return -1;
2558 }
2559 if (bdrv_key_required(bdrv))
2560 autostart = 0;
2561 return drives_table_idx;
2562}
2563
2564static void numa_add(const char *optarg)
2565{
2566 char option[128];
2567 char *endptr;
2568 unsigned long long value, endvalue;
2569 int nodenr;
2570
2571 optarg = get_opt_name(option, 128, optarg, ',') + 1;
2572 if (!strcmp(option, "node")) {
2573 if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2574 nodenr = nb_numa_nodes;
2575 } else {
2576 nodenr = strtoull(option, NULL, 10);
2577 }
2578
2579 if (get_param_value(option, 128, "mem", optarg) == 0) {
2580 node_mem[nodenr] = 0;
2581 } else {
2582 value = strtoull(option, &endptr, 0);
2583 switch (*endptr) {
2584 case 0: case 'M': case 'm':
2585 value <<= 20;
2586 break;
2587 case 'G': case 'g':
2588 value <<= 30;
2589 break;
2590 }
2591 node_mem[nodenr] = value;
2592 }
2593 if (get_param_value(option, 128, "cpus", optarg) == 0) {
2594 node_cpumask[nodenr] = 0;
2595 } else {
2596 value = strtoull(option, &endptr, 10);
2597 if (value >= 64) {
2598 value = 63;
2599 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2600 } else {
2601 if (*endptr == '-') {
2602 endvalue = strtoull(endptr+1, &endptr, 10);
2603 if (endvalue >= 63) {
2604 endvalue = 62;
2605 fprintf(stderr,
2606 "only 63 CPUs in NUMA mode supported.\n");
2607 }
2608 value = (1 << (endvalue + 1)) - (1 << value);
2609 } else {
2610 value = 1 << value;
2611 }
2612 }
2613 node_cpumask[nodenr] = value;
2614 }
2615 nb_numa_nodes++;
2616 }
2617 return;
2618}
2619
2620/***********************************************************/
2621/* USB devices */
2622
2623static USBPort *used_usb_ports;
2624static USBPort *free_usb_ports;
2625
2626/* ??? Maybe change this to register a hub to keep track of the topology. */
2627void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2628 usb_attachfn attach)
2629{
2630 port->opaque = opaque;
2631 port->index = index;
2632 port->attach = attach;
2633 port->next = free_usb_ports;
2634 free_usb_ports = port;
2635}
2636
2637int usb_device_add_dev(USBDevice *dev)
2638{
2639 USBPort *port;
2640
2641 /* Find a USB port to add the device to. */
2642 port = free_usb_ports;
2643 if (!port->next) {
2644 USBDevice *hub;
2645
2646 /* Create a new hub and chain it on. */
2647 free_usb_ports = NULL;
2648 port->next = used_usb_ports;
2649 used_usb_ports = port;
2650
2651 hub = usb_hub_init(VM_USB_HUB_SIZE);
2652 usb_attach(port, hub);
2653 port = free_usb_ports;
2654 }
2655
2656 free_usb_ports = port->next;
2657 port->next = used_usb_ports;
2658 used_usb_ports = port;
2659 usb_attach(port, dev);
2660 return 0;
2661}
2662
2663static void usb_msd_password_cb(void *opaque, int err)
2664{
2665 USBDevice *dev = opaque;
2666
2667 if (!err)
2668 usb_device_add_dev(dev);
2669 else
2670 dev->handle_destroy(dev);
2671}
2672
2673static int usb_device_add(const char *devname, int is_hotplug)
2674{
2675 const char *p;
2676 USBDevice *dev;
2677
2678 if (!free_usb_ports)
2679 return -1;
2680
2681 if (strstart(devname, "host:", &p)) {
2682 dev = usb_host_device_open(p);
2683 } else if (!strcmp(devname, "mouse")) {
2684 dev = usb_mouse_init();
2685 } else if (!strcmp(devname, "tablet")) {
2686 dev = usb_tablet_init();
2687 } else if (!strcmp(devname, "keyboard")) {
2688 dev = usb_keyboard_init();
2689 } else if (strstart(devname, "disk:", &p)) {
2690 BlockDriverState *bs;
2691
2692 dev = usb_msd_init(p);
2693 if (!dev)
2694 return -1;
2695 bs = usb_msd_get_bdrv(dev);
2696 if (bdrv_key_required(bs)) {
2697 autostart = 0;
2698 if (is_hotplug) {
2699 monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2700 dev);
2701 return 0;
2702 }
2703 }
2704 } else if (!strcmp(devname, "wacom-tablet")) {
2705 dev = usb_wacom_init();
2706 } else if (strstart(devname, "serial:", &p)) {
2707 dev = usb_serial_init(p);
2708#ifdef CONFIG_BRLAPI
2709 } else if (!strcmp(devname, "braille")) {
2710 dev = usb_baum_init();
2711#endif
2712 } else if (strstart(devname, "net:", &p)) {
2713 int nic = nb_nics;
2714
2715 if (net_client_init(NULL, "nic", p) < 0)
2716 return -1;
2717 nd_table[nic].model = "usb";
2718 dev = usb_net_init(&nd_table[nic]);
2719 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2720 dev = usb_bt_init(devname[2] ? hci_init(p) :
2721 bt_new_hci(qemu_find_bt_vlan(0)));
2722 } else {
2723 return -1;
2724 }
2725 if (!dev)
2726 return -1;
2727
2728 return usb_device_add_dev(dev);
2729}
2730
2731int usb_device_del_addr(int bus_num, int addr)
2732{
2733 USBPort *port;
2734 USBPort **lastp;
2735 USBDevice *dev;
2736
2737 if (!used_usb_ports)
2738 return -1;
2739
2740 if (bus_num != 0)
2741 return -1;
2742
2743 lastp = &used_usb_ports;
2744 port = used_usb_ports;
2745 while (port && port->dev->addr != addr) {
2746 lastp = &port->next;
2747 port = port->next;
2748 }
2749
2750 if (!port)
2751 return -1;
2752
2753 dev = port->dev;
2754 *lastp = port->next;
2755 usb_attach(port, NULL);
2756 dev->handle_destroy(dev);
2757 port->next = free_usb_ports;
2758 free_usb_ports = port;
2759 return 0;
2760}
2761
2762static int usb_device_del(const char *devname)
2763{
2764 int bus_num, addr;
2765 const char *p;
2766
2767 if (strstart(devname, "host:", &p))
2768 return usb_host_device_close(p);
2769
2770 if (!used_usb_ports)
2771 return -1;
2772
2773 p = strchr(devname, '.');
2774 if (!p)
2775 return -1;
2776 bus_num = strtoul(devname, NULL, 0);
2777 addr = strtoul(p + 1, NULL, 0);
2778
2779 return usb_device_del_addr(bus_num, addr);
2780}
2781
2782void do_usb_add(Monitor *mon, const char *devname)
2783{
2784 usb_device_add(devname, 1);
2785}
2786
2787void do_usb_del(Monitor *mon, const char *devname)
2788{
2789 usb_device_del(devname);
2790}
2791
2792void usb_info(Monitor *mon)
2793{
2794 USBDevice *dev;
2795 USBPort *port;
2796 const char *speed_str;
2797
2798 if (!usb_enabled) {
2799 monitor_printf(mon, "USB support not enabled\n");
2800 return;
2801 }
2802
2803 for (port = used_usb_ports; port; port = port->next) {
2804 dev = port->dev;
2805 if (!dev)
2806 continue;
2807 switch(dev->speed) {
2808 case USB_SPEED_LOW:
2809 speed_str = "1.5";
2810 break;
2811 case USB_SPEED_FULL:
2812 speed_str = "12";
2813 break;
2814 case USB_SPEED_HIGH:
2815 speed_str = "480";
2816 break;
2817 default:
2818 speed_str = "?";
2819 break;
2820 }
2821 monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2822 0, dev->addr, speed_str, dev->devname);
2823 }
2824}
2825
2826/***********************************************************/
2827/* PCMCIA/Cardbus */
2828
2829static struct pcmcia_socket_entry_s {
2830 PCMCIASocket *socket;
2831 struct pcmcia_socket_entry_s *next;
2832} *pcmcia_sockets = 0;
2833
2834void pcmcia_socket_register(PCMCIASocket *socket)
2835{
2836 struct pcmcia_socket_entry_s *entry;
2837
2838 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2839 entry->socket = socket;
2840 entry->next = pcmcia_sockets;
2841 pcmcia_sockets = entry;
2842}
2843
2844void pcmcia_socket_unregister(PCMCIASocket *socket)
2845{
2846 struct pcmcia_socket_entry_s *entry, **ptr;
2847
2848 ptr = &pcmcia_sockets;
2849 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2850 if (entry->socket == socket) {
2851 *ptr = entry->next;
2852 qemu_free(entry);
2853 }
2854}
2855
2856void pcmcia_info(Monitor *mon)
2857{
2858 struct pcmcia_socket_entry_s *iter;
2859
2860 if (!pcmcia_sockets)
2861 monitor_printf(mon, "No PCMCIA sockets\n");
2862
2863 for (iter = pcmcia_sockets; iter; iter = iter->next)
2864 monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2865 iter->socket->attached ? iter->socket->card_string :
2866 "Empty");
2867}
2868
2869/***********************************************************/
2870/* register display */
2871
2872struct DisplayAllocator default_allocator = {
2873 defaultallocator_create_displaysurface,
2874 defaultallocator_resize_displaysurface,
2875 defaultallocator_free_displaysurface
2876};
2877
2878void register_displaystate(DisplayState *ds)
2879{
2880 DisplayState **s;
2881 s = &display_state;
2882 while (*s != NULL)
2883 s = &(*s)->next;
2884 ds->next = NULL;
2885 *s = ds;
2886}
2887
2888DisplayState *get_displaystate(void)
2889{
2890 return display_state;
2891}
2892
2893DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2894{
2895 if(ds->allocator == &default_allocator) ds->allocator = da;
2896 return ds->allocator;
2897}
2898
2899/* dumb display */
2900
2901static void dumb_display_init(void)
2902{
2903 DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2904 ds->allocator = &default_allocator;
2905 ds->surface = qemu_create_displaysurface(ds, 640, 480);
2906 register_displaystate(ds);
2907}
2908
2909/***********************************************************/
2910/* I/O handling */
2911
2912typedef struct IOHandlerRecord {
2913 int fd;
2914 IOCanRWHandler *fd_read_poll;
2915 IOHandler *fd_read;
2916 IOHandler *fd_write;
2917 int deleted;
2918 void *opaque;
2919 /* temporary data */
2920 struct pollfd *ufd;
2921 struct IOHandlerRecord *next;
2922} IOHandlerRecord;
2923
2924static IOHandlerRecord *first_io_handler;
2925
2926/* XXX: fd_read_poll should be suppressed, but an API change is
2927 necessary in the character devices to suppress fd_can_read(). */
2928int qemu_set_fd_handler2(int fd,
2929 IOCanRWHandler *fd_read_poll,
2930 IOHandler *fd_read,
2931 IOHandler *fd_write,
2932 void *opaque)
2933{
2934 IOHandlerRecord **pioh, *ioh;
2935
2936 if (!fd_read && !fd_write) {
2937 pioh = &first_io_handler;
2938 for(;;) {
2939 ioh = *pioh;
2940 if (ioh == NULL)
2941 break;
2942 if (ioh->fd == fd) {
2943 ioh->deleted = 1;
2944 break;
2945 }
2946 pioh = &ioh->next;
2947 }
2948 } else {
2949 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2950 if (ioh->fd == fd)
2951 goto found;
2952 }
2953 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2954 ioh->next = first_io_handler;
2955 first_io_handler = ioh;
2956 found:
2957 ioh->fd = fd;
2958 ioh->fd_read_poll = fd_read_poll;
2959 ioh->fd_read = fd_read;
2960 ioh->fd_write = fd_write;
2961 ioh->opaque = opaque;
2962 ioh->deleted = 0;
2963 }
2964 return 0;
2965}
2966
2967int qemu_set_fd_handler(int fd,
2968 IOHandler *fd_read,
2969 IOHandler *fd_write,
2970 void *opaque)
2971{
2972 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2973}
2974
2975#ifdef _WIN32
2976/***********************************************************/
2977/* Polling handling */
2978
2979typedef struct PollingEntry {
2980 PollingFunc *func;
2981 void *opaque;
2982 struct PollingEntry *next;
2983} PollingEntry;
2984
2985static PollingEntry *first_polling_entry;
2986
2987int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2988{
2989 PollingEntry **ppe, *pe;
2990 pe = qemu_mallocz(sizeof(PollingEntry));
2991 pe->func = func;
2992 pe->opaque = opaque;
2993 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2994 *ppe = pe;
2995 return 0;
2996}
2997
2998void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2999{
3000 PollingEntry **ppe, *pe;
3001 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
3002 pe = *ppe;
3003 if (pe->func == func && pe->opaque == opaque) {
3004 *ppe = pe->next;
3005 qemu_free(pe);
3006 break;
3007 }
3008 }
3009}
3010
3011/***********************************************************/
3012/* Wait objects support */
3013typedef struct WaitObjects {
3014 int num;
3015 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3016 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3017 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3018} WaitObjects;
3019
3020static WaitObjects wait_objects = {0};
3021
3022int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3023{
3024 WaitObjects *w = &wait_objects;
3025
3026 if (w->num >= MAXIMUM_WAIT_OBJECTS)
3027 return -1;
3028 w->events[w->num] = handle;
3029 w->func[w->num] = func;
3030 w->opaque[w->num] = opaque;
3031 w->num++;
3032 return 0;
3033}
3034
3035void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3036{
3037 int i, found;
3038 WaitObjects *w = &wait_objects;
3039
3040 found = 0;
3041 for (i = 0; i < w->num; i++) {
3042 if (w->events[i] == handle)
3043 found = 1;
3044 if (found) {
3045 w->events[i] = w->events[i + 1];
3046 w->func[i] = w->func[i + 1];
3047 w->opaque[i] = w->opaque[i + 1];
3048 }
3049 }
3050 if (found)
3051 w->num--;
3052}
3053#endif
3054
3055/***********************************************************/
3056/* ram save/restore */
3057
3058static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3059{
3060 int v;
3061
3062 v = qemu_get_byte(f);
3063 switch(v) {
3064 case 0:
3065 if (qemu_get_buffer(f, buf, len) != len)
3066 return -EIO;
3067 break;
3068 case 1:
3069 v = qemu_get_byte(f);
3070 memset(buf, v, len);
3071 break;
3072 default:
3073 return -EINVAL;
3074 }
3075
3076 if (qemu_file_has_error(f))
3077 return -EIO;
3078
3079 return 0;
3080}
3081
3082static int ram_load_v1(QEMUFile *f, void *opaque)
3083{
3084 int ret;
3085 ram_addr_t i;
3086
3087 if (qemu_get_be32(f) != last_ram_offset)
3088 return -EINVAL;
3089 for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
3090 ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
3091 if (ret)
3092 return ret;
3093 }
3094 return 0;
3095}
3096
3097#define BDRV_HASH_BLOCK_SIZE 1024
3098#define IOBUF_SIZE 4096
3099#define RAM_CBLOCK_MAGIC 0xfabe
3100
3101typedef struct RamDecompressState {
3102 z_stream zstream;
3103 QEMUFile *f;
3104 uint8_t buf[IOBUF_SIZE];
3105} RamDecompressState;
3106
3107static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3108{
3109 int ret;
3110 memset(s, 0, sizeof(*s));
3111 s->f = f;
3112 ret = inflateInit(&s->zstream);
3113 if (ret != Z_OK)
3114 return -1;
3115 return 0;
3116}
3117
3118static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3119{
3120 int ret, clen;
3121
3122 s->zstream.avail_out = len;
3123 s->zstream.next_out = buf;
3124 while (s->zstream.avail_out > 0) {
3125 if (s->zstream.avail_in == 0) {
3126 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3127 return -1;
3128 clen = qemu_get_be16(s->f);
3129 if (clen > IOBUF_SIZE)
3130 return -1;
3131 qemu_get_buffer(s->f, s->buf, clen);
3132 s->zstream.avail_in = clen;
3133 s->zstream.next_in = s->buf;
3134 }
3135 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3136 if (ret != Z_OK && ret != Z_STREAM_END) {
3137 return -1;
3138 }
3139 }
3140 return 0;
3141}
3142
3143static void ram_decompress_close(RamDecompressState *s)
3144{
3145 inflateEnd(&s->zstream);
3146}
3147
3148#define RAM_SAVE_FLAG_FULL 0x01
3149#define RAM_SAVE_FLAG_COMPRESS 0x02
3150#define RAM_SAVE_FLAG_MEM_SIZE 0x04
3151#define RAM_SAVE_FLAG_PAGE 0x08
3152#define RAM_SAVE_FLAG_EOS 0x10
3153
3154static int is_dup_page(uint8_t *page, uint8_t ch)
3155{
3156 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3157 uint32_t *array = (uint32_t *)page;
3158 int i;
3159
3160 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3161 if (array[i] != val)
3162 return 0;
3163 }
3164
3165 return 1;
3166}
3167
3168static int ram_save_block(QEMUFile *f)
3169{
3170 static ram_addr_t current_addr = 0;
3171 ram_addr_t saved_addr = current_addr;
3172 ram_addr_t addr = 0;
3173 int found = 0;
3174
3175 while (addr < last_ram_offset) {
3176 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3177 uint8_t *p;
3178
3179 cpu_physical_memory_reset_dirty(current_addr,
3180 current_addr + TARGET_PAGE_SIZE,
3181 MIGRATION_DIRTY_FLAG);
3182
3183 p = qemu_get_ram_ptr(current_addr);
3184
3185 if (is_dup_page(p, *p)) {
3186 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3187 qemu_put_byte(f, *p);
3188 } else {
3189 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3190 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
3191 }
3192
3193 found = 1;
3194 break;
3195 }
3196 addr += TARGET_PAGE_SIZE;
3197 current_addr = (saved_addr + addr) % last_ram_offset;
3198 }
3199
3200 return found;
3201}
3202
3203static uint64_t bytes_transferred = 0;
3204
3205static ram_addr_t ram_save_remaining(void)
3206{
3207 ram_addr_t addr;
3208 ram_addr_t count = 0;
3209
3210 for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3211 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3212 count++;
3213 }
3214
3215 return count;
3216}
3217
3218uint64_t ram_bytes_remaining(void)
3219{
3220 return ram_save_remaining() * TARGET_PAGE_SIZE;
3221}
3222
3223uint64_t ram_bytes_transferred(void)
3224{
3225 return bytes_transferred;
3226}
3227
3228uint64_t ram_bytes_total(void)
3229{
3230 return last_ram_offset;
3231}
3232
3233static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3234{
3235 ram_addr_t addr;
3236 uint64_t bytes_transferred_last;
3237 double bwidth = 0;
3238 uint64_t expected_time = 0;
3239
3240 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
3241 qemu_file_set_error(f);
3242 return 0;
3243 }
3244
3245 if (stage == 1) {
3246 /* Make sure all dirty bits are set */
3247 for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3248 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3249 cpu_physical_memory_set_dirty(addr);
3250 }
3251
3252 /* Enable dirty memory tracking */
3253 cpu_physical_memory_set_dirty_tracking(1);
3254
3255 qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3256 }
3257
3258 bytes_transferred_last = bytes_transferred;
3259 bwidth = get_clock();
3260
3261 while (!qemu_file_rate_limit(f)) {
3262 int ret;
3263
3264 ret = ram_save_block(f);
3265 bytes_transferred += ret * TARGET_PAGE_SIZE;
3266 if (ret == 0) /* no more blocks */
3267 break;
3268 }
3269
3270 bwidth = get_clock() - bwidth;
3271 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
3272
3273 /* if we haven't transferred anything this round, force expected_time to a
3274 * a very high value, but without crashing */
3275 if (bwidth == 0)
3276 bwidth = 0.000001;
3277
3278 /* try transferring iterative blocks of memory */
3279
3280 if (stage == 3) {
3281
3282 /* flush all remaining blocks regardless of rate limiting */
3283 while (ram_save_block(f) != 0) {
3284 bytes_transferred += TARGET_PAGE_SIZE;
3285 }
3286 cpu_physical_memory_set_dirty_tracking(0);
3287 }
3288
3289 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3290
3291 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
3292
3293 return (stage == 2) && (expected_time <= migrate_max_downtime());
3294}
3295
3296static int ram_load_dead(QEMUFile *f, void *opaque)
3297{
3298 RamDecompressState s1, *s = &s1;
3299 uint8_t buf[10];
3300 ram_addr_t i;
3301
3302 if (ram_decompress_open(s, f) < 0)
3303 return -EINVAL;
3304 for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
3305 if (ram_decompress_buf(s, buf, 1) < 0) {
3306 fprintf(stderr, "Error while reading ram block header\n");
3307 goto error;
3308 }
3309 if (buf[0] == 0) {
3310 if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3311 BDRV_HASH_BLOCK_SIZE) < 0) {
3312 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3313 goto error;
3314 }
3315 } else {
3316 error:
3317 printf("Error block header\n");
3318 return -EINVAL;
3319 }
3320 }
3321 ram_decompress_close(s);
3322
3323 return 0;
3324}
3325
3326static int ram_load(QEMUFile *f, void *opaque, int version_id)
3327{
3328 ram_addr_t addr;
3329 int flags;
3330
3331 if (version_id == 1)
3332 return ram_load_v1(f, opaque);
3333
3334 if (version_id == 2) {
3335 if (qemu_get_be32(f) != last_ram_offset)
3336 return -EINVAL;
3337 return ram_load_dead(f, opaque);
3338 }
3339
3340 if (version_id != 3)
3341 return -EINVAL;
3342
3343 do {
3344 addr = qemu_get_be64(f);
3345
3346 flags = addr & ~TARGET_PAGE_MASK;
3347 addr &= TARGET_PAGE_MASK;
3348
3349 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3350 if (addr != last_ram_offset)
3351 return -EINVAL;
3352 }
3353
3354 if (flags & RAM_SAVE_FLAG_FULL) {
3355 if (ram_load_dead(f, opaque) < 0)
3356 return -EINVAL;
3357 }
3358
3359 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3360 uint8_t ch = qemu_get_byte(f);
3361#if defined(__linux__)
3362 if (ch == 0 &&
3363 (!kvm_enabled() || kvm_has_sync_mmu())) {
3364 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
3365 } else
3366#endif
3367 memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3368 } else if (flags & RAM_SAVE_FLAG_PAGE)
3369 qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3370 } while (!(flags & RAM_SAVE_FLAG_EOS));
3371
3372 return 0;
3373}
3374
3375void qemu_service_io(void)
3376{
3377 qemu_notify_event();
3378}
3379
3380/***********************************************************/
3381/* bottom halves (can be seen as timers which expire ASAP) */
3382
3383struct QEMUBH {
3384 QEMUBHFunc *cb;
3385 void *opaque;
3386 int scheduled;
3387 int idle;
3388 int deleted;
3389 QEMUBH *next;
3390};
3391
3392static QEMUBH *first_bh = NULL;
3393
3394QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3395{
3396 QEMUBH *bh;
3397 bh = qemu_mallocz(sizeof(QEMUBH));
3398 bh->cb = cb;
3399 bh->opaque = opaque;
3400 bh->next = first_bh;
3401 first_bh = bh;
3402 return bh;
3403}
3404
3405int qemu_bh_poll(void)
3406{
3407 QEMUBH *bh, **bhp;
3408 int ret;
3409
3410 ret = 0;
3411 for (bh = first_bh; bh; bh = bh->next) {
3412 if (!bh->deleted && bh->scheduled) {
3413 bh->scheduled = 0;
3414 if (!bh->idle)
3415 ret = 1;
3416 bh->idle = 0;
3417 bh->cb(bh->opaque);
3418 }
3419 }
3420
3421 /* remove deleted bhs */
3422 bhp = &first_bh;
3423 while (*bhp) {
3424 bh = *bhp;
3425 if (bh->deleted) {
3426 *bhp = bh->next;
3427 qemu_free(bh);
3428 } else
3429 bhp = &bh->next;
3430 }
3431
3432 return ret;
3433}
3434
3435void qemu_bh_schedule_idle(QEMUBH *bh)
3436{
3437 if (bh->scheduled)
3438 return;
3439 bh->scheduled = 1;
3440 bh->idle = 1;
3441}
3442
3443void qemu_bh_schedule(QEMUBH *bh)
3444{
3445 if (bh->scheduled)
3446 return;
3447 bh->scheduled = 1;
3448 bh->idle = 0;
3449 /* stop the currently executing CPU to execute the BH ASAP */
3450 qemu_notify_event();
3451}
3452
3453void qemu_bh_cancel(QEMUBH *bh)
3454{
3455 bh->scheduled = 0;
3456}
3457
3458void qemu_bh_delete(QEMUBH *bh)
3459{
3460 bh->scheduled = 0;
3461 bh->deleted = 1;
3462}
3463
3464static void qemu_bh_update_timeout(int *timeout)
3465{
3466 QEMUBH *bh;
3467
3468 for (bh = first_bh; bh; bh = bh->next) {
3469 if (!bh->deleted && bh->scheduled) {
3470 if (bh->idle) {
3471 /* idle bottom halves will be polled at least
3472 * every 10ms */
3473 *timeout = MIN(10, *timeout);
3474 } else {
3475 /* non-idle bottom halves will be executed
3476 * immediately */
3477 *timeout = 0;
3478 break;
3479 }
3480 }
3481 }
3482}
3483
3484/***********************************************************/
3485/* machine registration */
3486
3487static QEMUMachine *first_machine = NULL;
3488QEMUMachine *current_machine = NULL;
3489
3490int qemu_register_machine(QEMUMachine *m)
3491{
3492 QEMUMachine **pm;
3493 pm = &first_machine;
3494 while (*pm != NULL)
3495 pm = &(*pm)->next;
3496 m->next = NULL;
3497 *pm = m;
3498 return 0;
3499}
3500
3501static QEMUMachine *find_machine(const char *name)
3502{
3503 QEMUMachine *m;
3504
3505 for(m = first_machine; m != NULL; m = m->next) {
3506 if (!strcmp(m->name, name))
3507 return m;
3508 }
3509 return NULL;
3510}
3511
3512static QEMUMachine *find_default_machine(void)
3513{
3514 QEMUMachine *m;
3515
3516 for(m = first_machine; m != NULL; m = m->next) {
3517 if (m->is_default) {
3518 return m;
3519 }
3520 }
3521 return NULL;
3522}
3523
3524/***********************************************************/
3525/* main execution loop */
3526
3527static void gui_update(void *opaque)
3528{
3529 uint64_t interval = GUI_REFRESH_INTERVAL;
3530 DisplayState *ds = opaque;
3531 DisplayChangeListener *dcl = ds->listeners;
3532
3533 dpy_refresh(ds);
3534
3535 while (dcl != NULL) {
3536 if (dcl->gui_timer_interval &&
3537 dcl->gui_timer_interval < interval)
3538 interval = dcl->gui_timer_interval;
3539 dcl = dcl->next;
3540 }
3541 qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3542}
3543
3544static void nographic_update(void *opaque)
3545{
3546 uint64_t interval = GUI_REFRESH_INTERVAL;
3547
3548 qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3549}
3550
3551struct vm_change_state_entry {
3552 VMChangeStateHandler *cb;
3553 void *opaque;
3554 LIST_ENTRY (vm_change_state_entry) entries;
3555};
3556
3557static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3558
3559VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3560 void *opaque)
3561{
3562 VMChangeStateEntry *e;
3563
3564 e = qemu_mallocz(sizeof (*e));
3565
3566 e->cb = cb;
3567 e->opaque = opaque;
3568 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3569 return e;
3570}
3571
3572void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3573{
3574 LIST_REMOVE (e, entries);
3575 qemu_free (e);
3576}
3577
3578static void vm_state_notify(int running, int reason)
3579{
3580 VMChangeStateEntry *e;
3581
3582 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3583 e->cb(e->opaque, running, reason);
3584 }
3585}
3586
3587static void resume_all_vcpus(void);
3588static void pause_all_vcpus(void);
3589
3590void vm_start(void)
3591{
3592 if (!vm_running) {
3593 cpu_enable_ticks();
3594 vm_running = 1;
3595 vm_state_notify(1, 0);
3596 qemu_rearm_alarm_timer(alarm_timer);
3597 resume_all_vcpus();
3598 }
3599}
3600
3601/* reset/shutdown handler */
3602
3603typedef struct QEMUResetEntry {
3604 QEMUResetHandler *func;
3605 void *opaque;
3606 int order;
3607 struct QEMUResetEntry *next;
3608} QEMUResetEntry;
3609
3610static QEMUResetEntry *first_reset_entry;
3611static int reset_requested;
3612static int shutdown_requested;
3613static int powerdown_requested;
3614static int debug_requested;
3615static int vmstop_requested;
3616
3617int qemu_shutdown_requested(void)
3618{
3619 int r = shutdown_requested;
3620 shutdown_requested = 0;
3621 return r;
3622}
3623
3624int qemu_reset_requested(void)
3625{
3626 int r = reset_requested;
3627 reset_requested = 0;
3628 return r;
3629}
3630
3631int qemu_powerdown_requested(void)
3632{
3633 int r = powerdown_requested;
3634 powerdown_requested = 0;
3635 return r;
3636}
3637
3638static int qemu_debug_requested(void)
3639{
3640 int r = debug_requested;
3641 debug_requested = 0;
3642 return r;
3643}
3644
3645static int qemu_vmstop_requested(void)
3646{
3647 int r = vmstop_requested;
3648 vmstop_requested = 0;
3649 return r;
3650}
3651
3652static void do_vm_stop(int reason)
3653{
3654 if (vm_running) {
3655 cpu_disable_ticks();
3656 vm_running = 0;
3657 pause_all_vcpus();
3658 vm_state_notify(0, reason);
3659 }
3660}
3661
3662void qemu_register_reset(QEMUResetHandler *func, int order, void *opaque)
3663{
3664 QEMUResetEntry **pre, *re;
3665
3666 pre = &first_reset_entry;
3667 while (*pre != NULL && (*pre)->order >= order) {
3668 pre = &(*pre)->next;
3669 }
3670 re = qemu_mallocz(sizeof(QEMUResetEntry));
3671 re->func = func;
3672 re->opaque = opaque;
3673 re->order = order;
3674 re->next = NULL;
3675 *pre = re;
3676}
3677
3678void qemu_system_reset(void)
3679{
3680 QEMUResetEntry *re;
3681
3682 /* reset all devices */
3683 for(re = first_reset_entry; re != NULL; re = re->next) {
3684 re->func(re->opaque);
3685 }
3686}
3687
3688void qemu_system_reset_request(void)
3689{
3690 if (no_reboot) {
3691 shutdown_requested = 1;
3692 } else {
3693 reset_requested = 1;
3694 }
3695 qemu_notify_event();
3696}
3697
3698void qemu_system_shutdown_request(void)
3699{
3700 shutdown_requested = 1;
3701 qemu_notify_event();
3702}
3703
3704void qemu_system_powerdown_request(void)
3705{
3706 powerdown_requested = 1;
3707 qemu_notify_event();
3708}
3709
3710#ifdef CONFIG_IOTHREAD
3711static void qemu_system_vmstop_request(int reason)
3712{
3713 vmstop_requested = reason;
3714 qemu_notify_event();
3715}
3716#endif
3717
3718#ifndef _WIN32
3719static int io_thread_fd = -1;
3720
3721static void qemu_event_increment(void)
3722{
3723 static const char byte = 0;
3724
3725 if (io_thread_fd == -1)
3726 return;
3727
3728 write(io_thread_fd, &byte, sizeof(byte));
3729}
3730
3731static void qemu_event_read(void *opaque)
3732{
3733 int fd = (unsigned long)opaque;
3734 ssize_t len;
3735
3736 /* Drain the notify pipe */
3737 do {
3738 char buffer[512];
3739 len = read(fd, buffer, sizeof(buffer));
3740 } while ((len == -1 && errno == EINTR) || len > 0);
3741}
3742
3743static int qemu_event_init(void)
3744{
3745 int err;
3746 int fds[2];
3747
3748 err = pipe(fds);
3749 if (err == -1)
3750 return -errno;
3751
3752 err = fcntl_setfl(fds[0], O_NONBLOCK);
3753 if (err < 0)
3754 goto fail;
3755
3756 err = fcntl_setfl(fds[1], O_NONBLOCK);
3757 if (err < 0)
3758 goto fail;
3759
3760 qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3761 (void *)(unsigned long)fds[0]);
3762
3763 io_thread_fd = fds[1];
3764 return 0;
3765
3766fail:
3767 close(fds[0]);
3768 close(fds[1]);
3769 return err;
3770}
3771#else
3772HANDLE qemu_event_handle;
3773
3774static void dummy_event_handler(void *opaque)
3775{
3776}
3777
3778static int qemu_event_init(void)
3779{
3780 qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3781 if (!qemu_event_handle) {
3782 perror("Failed CreateEvent");
3783 return -1;
3784 }
3785 qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3786 return 0;
3787}
3788
3789static void qemu_event_increment(void)
3790{
3791 SetEvent(qemu_event_handle);
3792}
3793#endif
3794
3795static int cpu_can_run(CPUState *env)
3796{
3797 if (env->stop)
3798 return 0;
3799 if (env->stopped)
3800 return 0;
3801 return 1;
3802}
3803
3804#ifndef CONFIG_IOTHREAD
3805static int qemu_init_main_loop(void)
3806{
3807 return qemu_event_init();
3808}
3809
3810void qemu_init_vcpu(void *_env)
3811{
3812 CPUState *env = _env;
3813
3814 if (kvm_enabled())
3815 kvm_init_vcpu(env);
3816 return;
3817}
3818
3819int qemu_cpu_self(void *env)
3820{
3821 return 1;
3822}
3823
3824static void resume_all_vcpus(void)
3825{
3826}
3827
3828static void pause_all_vcpus(void)
3829{
3830}
3831
3832void qemu_cpu_kick(void *env)
3833{
3834 return;
3835}
3836
3837void qemu_notify_event(void)
3838{
3839 CPUState *env = cpu_single_env;
3840
3841 if (env) {
3842 cpu_exit(env);
3843#ifdef USE_KQEMU
3844 if (env->kqemu_enabled)
3845 kqemu_cpu_interrupt(env);
3846#endif
3847 }
3848}
3849
3850#define qemu_mutex_lock_iothread() do { } while (0)
3851#define qemu_mutex_unlock_iothread() do { } while (0)
3852
3853void vm_stop(int reason)
3854{
3855 do_vm_stop(reason);
3856}
3857
3858#else /* CONFIG_IOTHREAD */
3859
3860#include "qemu-thread.h"
3861
3862QemuMutex qemu_global_mutex;
3863static QemuMutex qemu_fair_mutex;
3864
3865static QemuThread io_thread;
3866
3867static QemuThread *tcg_cpu_thread;
3868static QemuCond *tcg_halt_cond;
3869
3870static int qemu_system_ready;
3871/* cpu creation */
3872static QemuCond qemu_cpu_cond;
3873/* system init */
3874static QemuCond qemu_system_cond;
3875static QemuCond qemu_pause_cond;
3876
3877static void block_io_signals(void);
3878static void unblock_io_signals(void);
3879static int tcg_has_work(void);
3880
3881static int qemu_init_main_loop(void)
3882{
3883 int ret;
3884
3885 ret = qemu_event_init();
3886 if (ret)
3887 return ret;
3888
3889 qemu_cond_init(&qemu_pause_cond);
3890 qemu_mutex_init(&qemu_fair_mutex);
3891 qemu_mutex_init(&qemu_global_mutex);
3892 qemu_mutex_lock(&qemu_global_mutex);
3893
3894 unblock_io_signals();
3895 qemu_thread_self(&io_thread);
3896
3897 return 0;
3898}
3899
3900static void qemu_wait_io_event(CPUState *env)
3901{
3902 while (!tcg_has_work())
3903 qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3904
3905 qemu_mutex_unlock(&qemu_global_mutex);
3906
3907 /*
3908 * Users of qemu_global_mutex can be starved, having no chance
3909 * to acquire it since this path will get to it first.
3910 * So use another lock to provide fairness.
3911 */
3912 qemu_mutex_lock(&qemu_fair_mutex);
3913 qemu_mutex_unlock(&qemu_fair_mutex);
3914
3915 qemu_mutex_lock(&qemu_global_mutex);
3916 if (env->stop) {
3917 env->stop = 0;
3918 env->stopped = 1;
3919 qemu_cond_signal(&qemu_pause_cond);
3920 }
3921}
3922
3923static int qemu_cpu_exec(CPUState *env);
3924
3925static void *kvm_cpu_thread_fn(void *arg)
3926{
3927 CPUState *env = arg;
3928
3929 block_io_signals();
3930 qemu_thread_self(env->thread);
3931
3932 /* signal CPU creation */
3933 qemu_mutex_lock(&qemu_global_mutex);
3934 env->created = 1;
3935 qemu_cond_signal(&qemu_cpu_cond);
3936
3937 /* and wait for machine initialization */
3938 while (!qemu_system_ready)
3939 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3940
3941 while (1) {
3942 if (cpu_can_run(env))
3943 qemu_cpu_exec(env);
3944 qemu_wait_io_event(env);
3945 }
3946
3947 return NULL;
3948}
3949
3950static void tcg_cpu_exec(void);
3951
3952static void *tcg_cpu_thread_fn(void *arg)
3953{
3954 CPUState *env = arg;
3955
3956 block_io_signals();
3957 qemu_thread_self(env->thread);
3958
3959 /* signal CPU creation */
3960 qemu_mutex_lock(&qemu_global_mutex);
3961 for (env = first_cpu; env != NULL; env = env->next_cpu)
3962 env->created = 1;
3963 qemu_cond_signal(&qemu_cpu_cond);
3964
3965 /* and wait for machine initialization */
3966 while (!qemu_system_ready)
3967 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3968
3969 while (1) {
3970 tcg_cpu_exec();
3971 qemu_wait_io_event(cur_cpu);
3972 }
3973
3974 return NULL;
3975}
3976
3977void qemu_cpu_kick(void *_env)
3978{
3979 CPUState *env = _env;
3980 qemu_cond_broadcast(env->halt_cond);
3981 if (kvm_enabled())
3982 qemu_thread_signal(env->thread, SIGUSR1);
3983}
3984
3985int qemu_cpu_self(void *env)
3986{
3987 return (cpu_single_env != NULL);
3988}
3989
3990static void cpu_signal(int sig)
3991{
3992 if (cpu_single_env)
3993 cpu_exit(cpu_single_env);
3994}
3995
3996static void block_io_signals(void)
3997{
3998 sigset_t set;
3999 struct sigaction sigact;
4000
4001 sigemptyset(&set);
4002 sigaddset(&set, SIGUSR2);
4003 sigaddset(&set, SIGIO);
4004 sigaddset(&set, SIGALRM);
4005 pthread_sigmask(SIG_BLOCK, &set, NULL);
4006
4007 sigemptyset(&set);
4008 sigaddset(&set, SIGUSR1);
4009 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4010
4011 memset(&sigact, 0, sizeof(sigact));
4012 sigact.sa_handler = cpu_signal;
4013 sigaction(SIGUSR1, &sigact, NULL);
4014}
4015
4016static void unblock_io_signals(void)
4017{
4018 sigset_t set;
4019
4020 sigemptyset(&set);
4021 sigaddset(&set, SIGUSR2);
4022 sigaddset(&set, SIGIO);
4023 sigaddset(&set, SIGALRM);
4024 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4025
4026 sigemptyset(&set);
4027 sigaddset(&set, SIGUSR1);
4028 pthread_sigmask(SIG_BLOCK, &set, NULL);
4029}
4030
4031static void qemu_signal_lock(unsigned int msecs)
4032{
4033 qemu_mutex_lock(&qemu_fair_mutex);
4034
4035 while (qemu_mutex_trylock(&qemu_global_mutex)) {
4036 qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
4037 if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
4038 break;
4039 }
4040 qemu_mutex_unlock(&qemu_fair_mutex);
4041}
4042
4043static void qemu_mutex_lock_iothread(void)
4044{
4045 if (kvm_enabled()) {
4046 qemu_mutex_lock(&qemu_fair_mutex);
4047 qemu_mutex_lock(&qemu_global_mutex);
4048 qemu_mutex_unlock(&qemu_fair_mutex);
4049 } else
4050 qemu_signal_lock(100);
4051}
4052
4053static void qemu_mutex_unlock_iothread(void)
4054{
4055 qemu_mutex_unlock(&qemu_global_mutex);
4056}
4057
4058static int all_vcpus_paused(void)
4059{
4060 CPUState *penv = first_cpu;
4061
4062 while (penv) {
4063 if (!penv->stopped)
4064 return 0;
4065 penv = (CPUState *)penv->next_cpu;
4066 }
4067
4068 return 1;
4069}
4070
4071static void pause_all_vcpus(void)
4072{
4073 CPUState *penv = first_cpu;
4074
4075 while (penv) {
4076 penv->stop = 1;
4077 qemu_thread_signal(penv->thread, SIGUSR1);
4078 qemu_cpu_kick(penv);
4079 penv = (CPUState *)penv->next_cpu;
4080 }
4081
4082 while (!all_vcpus_paused()) {
4083 qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
4084 penv = first_cpu;
4085 while (penv) {
4086 qemu_thread_signal(penv->thread, SIGUSR1);
4087 penv = (CPUState *)penv->next_cpu;
4088 }
4089 }
4090}
4091
4092static void resume_all_vcpus(void)
4093{
4094 CPUState *penv = first_cpu;
4095
4096 while (penv) {
4097 penv->stop = 0;
4098 penv->stopped = 0;
4099 qemu_thread_signal(penv->thread, SIGUSR1);
4100 qemu_cpu_kick(penv);
4101 penv = (CPUState *)penv->next_cpu;
4102 }
4103}
4104
4105static void tcg_init_vcpu(void *_env)
4106{
4107 CPUState *env = _env;
4108 /* share a single thread for all cpus with TCG */
4109 if (!tcg_cpu_thread) {
4110 env->thread = qemu_mallocz(sizeof(QemuThread));
4111 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4112 qemu_cond_init(env->halt_cond);
4113 qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
4114 while (env->created == 0)
4115 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4116 tcg_cpu_thread = env->thread;
4117 tcg_halt_cond = env->halt_cond;
4118 } else {
4119 env->thread = tcg_cpu_thread;
4120 env->halt_cond = tcg_halt_cond;
4121 }
4122}
4123
4124static void kvm_start_vcpu(CPUState *env)
4125{
4126 kvm_init_vcpu(env);
4127 env->thread = qemu_mallocz(sizeof(QemuThread));
4128 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4129 qemu_cond_init(env->halt_cond);
4130 qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
4131 while (env->created == 0)
4132 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4133}
4134
4135void qemu_init_vcpu(void *_env)
4136{
4137 CPUState *env = _env;
4138
4139 if (kvm_enabled())
4140 kvm_start_vcpu(env);
4141 else
4142 tcg_init_vcpu(env);
4143}
4144
4145void qemu_notify_event(void)
4146{
4147 qemu_event_increment();
4148}
4149
4150void vm_stop(int reason)
4151{
4152 QemuThread me;
4153 qemu_thread_self(&me);
4154
4155 if (!qemu_thread_equal(&me, &io_thread)) {
4156 qemu_system_vmstop_request(reason);
4157 /*
4158 * FIXME: should not return to device code in case
4159 * vm_stop() has been requested.
4160 */
4161 if (cpu_single_env) {
4162 cpu_exit(cpu_single_env);
4163 cpu_single_env->stop = 1;
4164 }
4165 return;
4166 }
4167 do_vm_stop(reason);
4168}
4169
4170#endif
4171
4172
4173#ifdef _WIN32
4174static void host_main_loop_wait(int *timeout)
4175{
4176 int ret, ret2, i;
4177 PollingEntry *pe;
4178
4179
4180 /* XXX: need to suppress polling by better using win32 events */
4181 ret = 0;
4182 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4183 ret |= pe->func(pe->opaque);
4184 }
4185 if (ret == 0) {
4186 int err;
4187 WaitObjects *w = &wait_objects;
4188
4189 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
4190 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
4191 if (w->func[ret - WAIT_OBJECT_0])
4192 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
4193
4194 /* Check for additional signaled events */
4195 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
4196
4197 /* Check if event is signaled */
4198 ret2 = WaitForSingleObject(w->events[i], 0);
4199 if(ret2 == WAIT_OBJECT_0) {
4200 if (w->func[i])
4201 w->func[i](w->opaque[i]);
4202 } else if (ret2 == WAIT_TIMEOUT) {
4203 } else {
4204 err = GetLastError();
4205 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
4206 }
4207 }
4208 } else if (ret == WAIT_TIMEOUT) {
4209 } else {
4210 err = GetLastError();
4211 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
4212 }
4213 }
4214
4215 *timeout = 0;
4216}
4217#else
4218static void host_main_loop_wait(int *timeout)
4219{
4220}
4221#endif
4222
4223void main_loop_wait(int timeout)
4224{
4225 IOHandlerRecord *ioh;
4226 fd_set rfds, wfds, xfds;
4227 int ret, nfds;
4228 struct timeval tv;
4229
4230 qemu_bh_update_timeout(&timeout);
4231
4232 host_main_loop_wait(&timeout);
4233
4234 /* poll any events */
4235 /* XXX: separate device handlers from system ones */
4236 nfds = -1;
4237 FD_ZERO(&rfds);
4238 FD_ZERO(&wfds);
4239 FD_ZERO(&xfds);
4240 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4241 if (ioh->deleted)
4242 continue;
4243 if (ioh->fd_read &&
4244 (!ioh->fd_read_poll ||
4245 ioh->fd_read_poll(ioh->opaque) != 0)) {
4246 FD_SET(ioh->fd, &rfds);
4247 if (ioh->fd > nfds)
4248 nfds = ioh->fd;
4249 }
4250 if (ioh->fd_write) {
4251 FD_SET(ioh->fd, &wfds);
4252 if (ioh->fd > nfds)
4253 nfds = ioh->fd;
4254 }
4255 }
4256
4257 tv.tv_sec = timeout / 1000;
4258 tv.tv_usec = (timeout % 1000) * 1000;
4259
4260#if defined(CONFIG_SLIRP)
4261 if (slirp_is_inited()) {
4262 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4263 }
4264#endif
4265 qemu_mutex_unlock_iothread();
4266 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4267 qemu_mutex_lock_iothread();
4268 if (ret > 0) {
4269 IOHandlerRecord **pioh;
4270
4271 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4272 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
4273 ioh->fd_read(ioh->opaque);
4274 }
4275 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
4276 ioh->fd_write(ioh->opaque);
4277 }
4278 }
4279
4280 /* remove deleted IO handlers */
4281 pioh = &first_io_handler;
4282 while (*pioh) {
4283 ioh = *pioh;
4284 if (ioh->deleted) {
4285 *pioh = ioh->next;
4286 qemu_free(ioh);
4287 } else
4288 pioh = &ioh->next;
4289 }
4290 }
4291#if defined(CONFIG_SLIRP)
4292 if (slirp_is_inited()) {
4293 if (ret < 0) {
4294 FD_ZERO(&rfds);
4295 FD_ZERO(&wfds);
4296 FD_ZERO(&xfds);
4297 }
4298 slirp_select_poll(&rfds, &wfds, &xfds);
4299 }
4300#endif
4301
4302 /* rearm timer, if not periodic */
4303 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4304 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4305 qemu_rearm_alarm_timer(alarm_timer);
4306 }
4307
4308 /* vm time timers */
4309 if (vm_running) {
4310 if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4311 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4312 qemu_get_clock(vm_clock));
4313 }
4314
4315 /* real time timers */
4316 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4317 qemu_get_clock(rt_clock));
4318
4319 /* Check bottom-halves last in case any of the earlier events triggered
4320 them. */
4321 qemu_bh_poll();
4322
4323}
4324
4325static int qemu_cpu_exec(CPUState *env)
4326{
4327 int ret;
4328#ifdef CONFIG_PROFILER
4329 int64_t ti;
4330#endif
4331
4332#ifdef CONFIG_PROFILER
4333 ti = profile_getclock();
4334#endif
4335 if (use_icount) {
4336 int64_t count;
4337 int decr;
4338 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4339 env->icount_decr.u16.low = 0;
4340 env->icount_extra = 0;
4341 count = qemu_next_deadline();
4342 count = (count + (1 << icount_time_shift) - 1)
4343 >> icount_time_shift;
4344 qemu_icount += count;
4345 decr = (count > 0xffff) ? 0xffff : count;
4346 count -= decr;
4347 env->icount_decr.u16.low = decr;
4348 env->icount_extra = count;
4349 }
4350 ret = cpu_exec(env);
4351#ifdef CONFIG_PROFILER
4352 qemu_time += profile_getclock() - ti;
4353#endif
4354 if (use_icount) {
4355 /* Fold pending instructions back into the
4356 instruction counter, and clear the interrupt flag. */
4357 qemu_icount -= (env->icount_decr.u16.low
4358 + env->icount_extra);
4359 env->icount_decr.u32 = 0;
4360 env->icount_extra = 0;
4361 }
4362 return ret;
4363}
4364
4365static void tcg_cpu_exec(void)
4366{
4367 int ret = 0;
4368
4369 if (next_cpu == NULL)
4370 next_cpu = first_cpu;
4371 for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4372 CPUState *env = cur_cpu = next_cpu;
4373
4374 if (!vm_running)
4375 break;
4376 if (timer_alarm_pending) {
4377 timer_alarm_pending = 0;
4378 break;
4379 }
4380 if (cpu_can_run(env))
4381 ret = qemu_cpu_exec(env);
4382 if (ret == EXCP_DEBUG) {
4383 gdb_set_stop_cpu(env);
4384 debug_requested = 1;
4385 break;
4386 }
4387 }
4388}
4389
4390static int cpu_has_work(CPUState *env)
4391{
4392 if (env->stop)
4393 return 1;
4394 if (env->stopped)
4395 return 0;
4396 if (!env->halted)
4397 return 1;
4398 if (qemu_cpu_has_work(env))
4399 return 1;
4400 return 0;
4401}
4402
4403static int tcg_has_work(void)
4404{
4405 CPUState *env;
4406
4407 for (env = first_cpu; env != NULL; env = env->next_cpu)
4408 if (cpu_has_work(env))
4409 return 1;
4410 return 0;
4411}
4412
4413static int qemu_calculate_timeout(void)
4414{
4415#ifndef CONFIG_IOTHREAD
4416 int timeout;
4417
4418 if (!vm_running)
4419 timeout = 5000;
4420 else if (tcg_has_work())
4421 timeout = 0;
4422 else if (!use_icount)
4423 timeout = 5000;
4424 else {
4425 /* XXX: use timeout computed from timers */
4426 int64_t add;
4427 int64_t delta;
4428 /* Advance virtual time to the next event. */
4429 if (use_icount == 1) {
4430 /* When not using an adaptive execution frequency
4431 we tend to get badly out of sync with real time,
4432 so just delay for a reasonable amount of time. */
4433 delta = 0;
4434 } else {
4435 delta = cpu_get_icount() - cpu_get_clock();
4436 }
4437 if (delta > 0) {
4438 /* If virtual time is ahead of real time then just
4439 wait for IO. */
4440 timeout = (delta / 1000000) + 1;
4441 } else {
4442 /* Wait for either IO to occur or the next
4443 timer event. */
4444 add = qemu_next_deadline();
4445 /* We advance the timer before checking for IO.
4446 Limit the amount we advance so that early IO
4447 activity won't get the guest too far ahead. */
4448 if (add > 10000000)
4449 add = 10000000;
4450 delta += add;
4451 add = (add + (1 << icount_time_shift) - 1)
4452 >> icount_time_shift;
4453 qemu_icount += add;
4454 timeout = delta / 1000000;
4455 if (timeout < 0)
4456 timeout = 0;
4457 }
4458 }
4459
4460 return timeout;
4461#else /* CONFIG_IOTHREAD */
4462 return 1000;
4463#endif
4464}
4465
4466static int vm_can_run(void)
4467{
4468 if (powerdown_requested)
4469 return 0;
4470 if (reset_requested)
4471 return 0;
4472 if (shutdown_requested)
4473 return 0;
4474 if (debug_requested)
4475 return 0;
4476 return 1;
4477}
4478
4479static void main_loop(void)
4480{
4481 int r;
4482
4483#ifdef CONFIG_IOTHREAD
4484 qemu_system_ready = 1;
4485 qemu_cond_broadcast(&qemu_system_cond);
4486#endif
4487
4488 for (;;) {
4489 do {
4490#ifdef CONFIG_PROFILER
4491 int64_t ti;
4492#endif
4493#ifndef CONFIG_IOTHREAD
4494 tcg_cpu_exec();
4495#endif
4496#ifdef CONFIG_PROFILER
4497 ti = profile_getclock();
4498#endif
4499 main_loop_wait(qemu_calculate_timeout());
4500#ifdef CONFIG_PROFILER
4501 dev_time += profile_getclock() - ti;
4502#endif
4503 } while (vm_can_run());
4504
4505 if (qemu_debug_requested())
4506 vm_stop(EXCP_DEBUG);
4507 if (qemu_shutdown_requested()) {
4508 if (no_shutdown) {
4509 vm_stop(0);
4510 no_shutdown = 0;
4511 } else
4512 break;
4513 }
4514 if (qemu_reset_requested()) {
4515 pause_all_vcpus();
4516 qemu_system_reset();
4517 resume_all_vcpus();
4518 }
4519 if (qemu_powerdown_requested())
4520 qemu_system_powerdown();
4521 if ((r = qemu_vmstop_requested()))
4522 vm_stop(r);
4523 }
4524 pause_all_vcpus();
4525}
4526
4527static void version(void)
4528{
4529 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4530}
4531
4532static void help(int exitcode)
4533{
4534 version();
4535 printf("usage: %s [options] [disk_image]\n"
4536 "\n"
4537 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4538 "\n"
4539#define DEF(option, opt_arg, opt_enum, opt_help) \
4540 opt_help
4541#define DEFHEADING(text) stringify(text) "\n"
4542#include "qemu-options.h"
4543#undef DEF
4544#undef DEFHEADING
4545#undef GEN_DOCS
4546 "\n"
4547 "During emulation, the following keys are useful:\n"
4548 "ctrl-alt-f toggle full screen\n"
4549 "ctrl-alt-n switch to virtual console 'n'\n"
4550 "ctrl-alt toggle mouse and keyboard grab\n"
4551 "\n"
4552 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4553 ,
4554 "qemu",
4555 DEFAULT_RAM_SIZE,
4556#ifndef _WIN32
4557 DEFAULT_NETWORK_SCRIPT,
4558 DEFAULT_NETWORK_DOWN_SCRIPT,
4559#endif
4560 DEFAULT_GDBSTUB_PORT,
4561 "/tmp/qemu.log");
4562 exit(exitcode);
4563}
4564
4565#define HAS_ARG 0x0001
4566
4567enum {
4568#define DEF(option, opt_arg, opt_enum, opt_help) \
4569 opt_enum,
4570#define DEFHEADING(text)
4571#include "qemu-options.h"
4572#undef DEF
4573#undef DEFHEADING
4574#undef GEN_DOCS
4575};
4576
4577typedef struct QEMUOption {
4578 const char *name;
4579 int flags;
4580 int index;
4581} QEMUOption;
4582
4583static const QEMUOption qemu_options[] = {
4584 { "h", 0, QEMU_OPTION_h },
4585#define DEF(option, opt_arg, opt_enum, opt_help) \
4586 { option, opt_arg, opt_enum },
4587#define DEFHEADING(text)
4588#include "qemu-options.h"
4589#undef DEF
4590#undef DEFHEADING
4591#undef GEN_DOCS
4592 { NULL },
4593};
4594
4595#ifdef HAS_AUDIO
4596struct soundhw soundhw[] = {
4597#ifdef HAS_AUDIO_CHOICE
4598#if defined(TARGET_I386) || defined(TARGET_MIPS)
4599 {
4600 "pcspk",
4601 "PC speaker",
4602 0,
4603 1,
4604 { .init_isa = pcspk_audio_init }
4605 },
4606#endif
4607
4608#ifdef CONFIG_SB16
4609 {
4610 "sb16",
4611 "Creative Sound Blaster 16",
4612 0,
4613 1,
4614 { .init_isa = SB16_init }
4615 },
4616#endif
4617
4618#ifdef CONFIG_CS4231A
4619 {
4620 "cs4231a",
4621 "CS4231A",
4622 0,
4623 1,
4624 { .init_isa = cs4231a_init }
4625 },
4626#endif
4627
4628#ifdef CONFIG_ADLIB
4629 {
4630 "adlib",
4631#ifdef HAS_YMF262
4632 "Yamaha YMF262 (OPL3)",
4633#else
4634 "Yamaha YM3812 (OPL2)",
4635#endif
4636 0,
4637 1,
4638 { .init_isa = Adlib_init }
4639 },
4640#endif
4641
4642#ifdef CONFIG_GUS
4643 {
4644 "gus",
4645 "Gravis Ultrasound GF1",
4646 0,
4647 1,
4648 { .init_isa = GUS_init }
4649 },
4650#endif
4651
4652#ifdef CONFIG_AC97
4653 {
4654 "ac97",
4655 "Intel 82801AA AC97 Audio",
4656 0,
4657 0,
4658 { .init_pci = ac97_init }
4659 },
4660#endif
4661
4662#ifdef CONFIG_ES1370
4663 {
4664 "es1370",
4665 "ENSONIQ AudioPCI ES1370",
4666 0,
4667 0,
4668 { .init_pci = es1370_init }
4669 },
4670#endif
4671
4672#endif /* HAS_AUDIO_CHOICE */
4673
4674 { NULL, NULL, 0, 0, { NULL } }
4675};
4676
4677static void select_soundhw (const char *optarg)
4678{
4679 struct soundhw *c;
4680
4681 if (*optarg == '?') {
4682 show_valid_cards:
4683
4684 printf ("Valid sound card names (comma separated):\n");
4685 for (c = soundhw; c->name; ++c) {
4686 printf ("%-11s %s\n", c->name, c->descr);
4687 }
4688 printf ("\n-soundhw all will enable all of the above\n");
4689 exit (*optarg != '?');
4690 }
4691 else {
4692 size_t l;
4693 const char *p;
4694 char *e;
4695 int bad_card = 0;
4696
4697 if (!strcmp (optarg, "all")) {
4698 for (c = soundhw; c->name; ++c) {
4699 c->enabled = 1;
4700 }
4701 return;
4702 }
4703
4704 p = optarg;
4705 while (*p) {
4706 e = strchr (p, ',');
4707 l = !e ? strlen (p) : (size_t) (e - p);
4708
4709 for (c = soundhw; c->name; ++c) {
4710 if (!strncmp (c->name, p, l)) {
4711 c->enabled = 1;
4712 break;
4713 }
4714 }
4715
4716 if (!c->name) {
4717 if (l > 80) {
4718 fprintf (stderr,
4719 "Unknown sound card name (too big to show)\n");
4720 }
4721 else {
4722 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4723 (int) l, p);
4724 }
4725 bad_card = 1;
4726 }
4727 p += l + (e != NULL);
4728 }
4729
4730 if (bad_card)
4731 goto show_valid_cards;
4732 }
4733}
4734#endif
4735
4736static void select_vgahw (const char *p)
4737{
4738 const char *opts;
4739
4740 cirrus_vga_enabled = 0;
4741 std_vga_enabled = 0;
4742 vmsvga_enabled = 0;
4743 xenfb_enabled = 0;
4744 if (strstart(p, "std", &opts)) {
4745 std_vga_enabled = 1;
4746 } else if (strstart(p, "cirrus", &opts)) {
4747 cirrus_vga_enabled = 1;
4748 } else if (strstart(p, "vmware", &opts)) {
4749 vmsvga_enabled = 1;
4750 } else if (strstart(p, "xenfb", &opts)) {
4751 xenfb_enabled = 1;
4752 } else if (!strstart(p, "none", &opts)) {
4753 invalid_vga:
4754 fprintf(stderr, "Unknown vga type: %s\n", p);
4755 exit(1);
4756 }
4757 while (*opts) {
4758 const char *nextopt;
4759
4760 if (strstart(opts, ",retrace=", &nextopt)) {
4761 opts = nextopt;
4762 if (strstart(opts, "dumb", &nextopt))
4763 vga_retrace_method = VGA_RETRACE_DUMB;
4764 else if (strstart(opts, "precise", &nextopt))
4765 vga_retrace_method = VGA_RETRACE_PRECISE;
4766 else goto invalid_vga;
4767 } else goto invalid_vga;
4768 opts = nextopt;
4769 }
4770}
4771
4772#ifdef _WIN32
4773static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4774{
4775 exit(STATUS_CONTROL_C_EXIT);
4776 return TRUE;
4777}
4778#endif
4779
4780int qemu_uuid_parse(const char *str, uint8_t *uuid)
4781{
4782 int ret;
4783
4784 if(strlen(str) != 36)
4785 return -1;
4786
4787 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4788 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4789 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4790
4791 if(ret != 16)
4792 return -1;
4793
4794#ifdef TARGET_I386
4795 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4796#endif
4797
4798 return 0;
4799}
4800
4801#define MAX_NET_CLIENTS 32
4802
4803#ifndef _WIN32
4804
4805static void termsig_handler(int signal)
4806{
4807 qemu_system_shutdown_request();
4808}
4809
4810static void sigchld_handler(int signal)
4811{
4812 waitpid(-1, NULL, WNOHANG);
4813}
4814
4815static void sighandler_setup(void)
4816{
4817 struct sigaction act;
4818
4819 memset(&act, 0, sizeof(act));
4820 act.sa_handler = termsig_handler;
4821 sigaction(SIGINT, &act, NULL);
4822 sigaction(SIGHUP, &act, NULL);
4823 sigaction(SIGTERM, &act, NULL);
4824
4825 act.sa_handler = sigchld_handler;
4826 act.sa_flags = SA_NOCLDSTOP;
4827 sigaction(SIGCHLD, &act, NULL);
4828}
4829
4830#endif
4831
4832#ifdef _WIN32
4833/* Look for support files in the same directory as the executable. */
4834static char *find_datadir(const char *argv0)
4835{
4836 char *p;
4837 char buf[MAX_PATH];
4838 DWORD len;
4839
4840 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4841 if (len == 0) {
4842 return NULL;
4843 }
4844
4845 buf[len] = 0;
4846 p = buf + len - 1;
4847 while (p != buf && *p != '\\')
4848 p--;
4849 *p = 0;
4850 if (access(buf, R_OK) == 0) {
4851 return qemu_strdup(buf);
4852 }
4853 return NULL;
4854}
4855#else /* !_WIN32 */
4856
4857/* Find a likely location for support files using the location of the binary.
4858 For installed binaries this will be "$bindir/../share/qemu". When
4859 running from the build tree this will be "$bindir/../pc-bios". */
4860#define SHARE_SUFFIX "/share/qemu"
4861#define BUILD_SUFFIX "/pc-bios"
4862static char *find_datadir(const char *argv0)
4863{
4864 char *dir;
4865 char *p = NULL;
4866 char *res;
4867#ifdef PATH_MAX
4868 char buf[PATH_MAX];
4869#endif
4870 size_t max_len;
4871
4872#if defined(__linux__)
4873 {
4874 int len;
4875 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4876 if (len > 0) {
4877 buf[len] = 0;
4878 p = buf;
4879 }
4880 }
4881#elif defined(__FreeBSD__)
4882 {
4883 int len;
4884 len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4885 if (len > 0) {
4886 buf[len] = 0;
4887 p = buf;
4888 }
4889 }
4890#endif
4891 /* If we don't have any way of figuring out the actual executable
4892 location then try argv[0]. */
4893 if (!p) {
4894#ifdef PATH_MAX
4895 p = buf;
4896#endif
4897 p = realpath(argv0, p);
4898 if (!p) {
4899 return NULL;
4900 }
4901 }
4902 dir = dirname(p);
4903 dir = dirname(dir);
4904
4905 max_len = strlen(dir) +
4906 MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4907 res = qemu_mallocz(max_len);
4908 snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4909 if (access(res, R_OK)) {
4910 snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4911 if (access(res, R_OK)) {
4912 qemu_free(res);
4913 res = NULL;
4914 }
4915 }
4916#ifndef PATH_MAX
4917 free(p);
4918#endif
4919 return res;
4920}
4921#undef SHARE_SUFFIX
4922#undef BUILD_SUFFIX
4923#endif
4924
4925char *qemu_find_file(int type, const char *name)
4926{
4927 int len;
4928 const char *subdir;
4929 char *buf;
4930
4931 /* If name contains path separators then try it as a straight path. */
4932 if ((strchr(name, '/') || strchr(name, '\\'))
4933 && access(name, R_OK) == 0) {
4934 return strdup(name);
4935 }
4936 switch (type) {
4937 case QEMU_FILE_TYPE_BIOS:
4938 subdir = "";
4939 break;
4940 case QEMU_FILE_TYPE_KEYMAP:
4941 subdir = "keymaps/";
4942 break;
4943 default:
4944 abort();
4945 }
4946 len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4947 buf = qemu_mallocz(len);
4948 snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4949 if (access(buf, R_OK)) {
4950 qemu_free(buf);
4951 return NULL;
4952 }
4953 return buf;
4954}
4955
4956int main(int argc, char **argv, char **envp)
4957{
4958 const char *gdbstub_dev = NULL;
4959 uint32_t boot_devices_bitmap = 0;
4960 int i;
4961 int snapshot, linux_boot, net_boot;
4962 const char *initrd_filename;
4963 const char *kernel_filename, *kernel_cmdline;
4964 const char *boot_devices = "";
4965 DisplayState *ds;
4966 DisplayChangeListener *dcl;
4967 int cyls, heads, secs, translation;
4968 const char *net_clients[MAX_NET_CLIENTS];
4969 int nb_net_clients;
4970 const char *bt_opts[MAX_BT_CMDLINE];
4971 int nb_bt_opts;
4972 int hda_index;
4973 int optind;
4974 const char *r, *optarg;
4975 CharDriverState *monitor_hd = NULL;
4976 const char *monitor_device;
4977 const char *serial_devices[MAX_SERIAL_PORTS];
4978 int serial_device_index;
4979 const char *parallel_devices[MAX_PARALLEL_PORTS];
4980 int parallel_device_index;
4981 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4982 int virtio_console_index;
4983 const char *loadvm = NULL;
4984 QEMUMachine *machine;
4985 const char *cpu_model;
4986 const char *usb_devices[MAX_USB_CMDLINE];
4987 int usb_devices_index;
4988#ifndef _WIN32
4989 int fds[2];
4990#endif
4991 int tb_size;
4992 const char *pid_file = NULL;
4993 const char *incoming = NULL;
4994#ifndef _WIN32
4995 int fd = 0;
4996 struct passwd *pwd = NULL;
4997 const char *chroot_dir = NULL;
4998 const char *run_as = NULL;
4999#endif
5000 CPUState *env;
5001 int show_vnc_port = 0;
5002
5003 qemu_cache_utils_init(envp);
5004
5005 LIST_INIT (&vm_change_state_head);
5006#ifndef _WIN32
5007 {
5008 struct sigaction act;
5009 sigfillset(&act.sa_mask);
5010 act.sa_flags = 0;
5011 act.sa_handler = SIG_IGN;
5012 sigaction(SIGPIPE, &act, NULL);
5013 }
5014#else
5015 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
5016 /* Note: cpu_interrupt() is currently not SMP safe, so we force
5017 QEMU to run on a single CPU */
5018 {
5019 HANDLE h;
5020 DWORD mask, smask;
5021 int i;
5022 h = GetCurrentProcess();
5023 if (GetProcessAffinityMask(h, &mask, &smask)) {
5024 for(i = 0; i < 32; i++) {
5025 if (mask & (1 << i))
5026 break;
5027 }
5028 if (i != 32) {
5029 mask = 1 << i;
5030 SetProcessAffinityMask(h, mask);
5031 }
5032 }
5033 }
5034#endif
5035
5036 module_call_init(MODULE_INIT_MACHINE);
5037 machine = find_default_machine();
5038 cpu_model = NULL;
5039 initrd_filename = NULL;
5040 ram_size = 0;
5041 snapshot = 0;
5042 kernel_filename = NULL;
5043 kernel_cmdline = "";
5044 cyls = heads = secs = 0;
5045 translation = BIOS_ATA_TRANSLATION_AUTO;
5046 monitor_device = "vc:80Cx24C";
5047
5048 serial_devices[0] = "vc:80Cx24C";
5049 for(i = 1; i < MAX_SERIAL_PORTS; i++)
5050 serial_devices[i] = NULL;
5051 serial_device_index = 0;
5052
5053 parallel_devices[0] = "vc:80Cx24C";
5054 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
5055 parallel_devices[i] = NULL;
5056 parallel_device_index = 0;
5057
5058 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
5059 virtio_consoles[i] = NULL;
5060 virtio_console_index = 0;
5061
5062 for (i = 0; i < MAX_NODES; i++) {
5063 node_mem[i] = 0;
5064 node_cpumask[i] = 0;
5065 }
5066
5067 usb_devices_index = 0;
5068
5069 nb_net_clients = 0;
5070 nb_bt_opts = 0;
5071 nb_drives = 0;
5072 nb_drives_opt = 0;
5073 nb_numa_nodes = 0;
5074 hda_index = -1;
5075
5076 nb_nics = 0;
5077
5078 tb_size = 0;
5079 autostart= 1;
5080
5081 register_watchdogs();
5082
5083 optind = 1;
5084 for(;;) {
5085 if (optind >= argc)
5086 break;
5087 r = argv[optind];
5088 if (r[0] != '-') {
5089 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
5090 } else {
5091 const QEMUOption *popt;
5092
5093 optind++;
5094 /* Treat --foo the same as -foo. */
5095 if (r[1] == '-')
5096 r++;
5097 popt = qemu_options;
5098 for(;;) {
5099 if (!popt->name) {
5100 fprintf(stderr, "%s: invalid option -- '%s'\n",
5101 argv[0], r);
5102 exit(1);
5103 }
5104 if (!strcmp(popt->name, r + 1))
5105 break;
5106 popt++;
5107 }
5108 if (popt->flags & HAS_ARG) {
5109 if (optind >= argc) {
5110 fprintf(stderr, "%s: option '%s' requires an argument\n",
5111 argv[0], r);
5112 exit(1);
5113 }
5114 optarg = argv[optind++];
5115 } else {
5116 optarg = NULL;
5117 }
5118
5119 switch(popt->index) {
5120 case QEMU_OPTION_M:
5121 machine = find_machine(optarg);
5122 if (!machine) {
5123 QEMUMachine *m;
5124 printf("Supported machines are:\n");
5125 for(m = first_machine; m != NULL; m = m->next) {
5126 printf("%-10s %s%s\n",
5127 m->name, m->desc,
5128 m->is_default ? " (default)" : "");
5129 }
5130 exit(*optarg != '?');
5131 }
5132 break;
5133 case QEMU_OPTION_cpu:
5134 /* hw initialization will check this */
5135 if (*optarg == '?') {
5136/* XXX: implement xxx_cpu_list for targets that still miss it */
5137#if defined(cpu_list)
5138 cpu_list(stdout, &fprintf);
5139#endif
5140 exit(0);
5141 } else {
5142 cpu_model = optarg;
5143 }
5144 break;
5145 case QEMU_OPTION_initrd:
5146 initrd_filename = optarg;
5147 break;
5148 case QEMU_OPTION_hda:
5149 if (cyls == 0)
5150 hda_index = drive_add(optarg, HD_ALIAS, 0);
5151 else
5152 hda_index = drive_add(optarg, HD_ALIAS
5153 ",cyls=%d,heads=%d,secs=%d%s",
5154 0, cyls, heads, secs,
5155 translation == BIOS_ATA_TRANSLATION_LBA ?
5156 ",trans=lba" :
5157 translation == BIOS_ATA_TRANSLATION_NONE ?
5158 ",trans=none" : "");
5159 break;
5160 case QEMU_OPTION_hdb:
5161 case QEMU_OPTION_hdc:
5162 case QEMU_OPTION_hdd:
5163 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
5164 break;
5165 case QEMU_OPTION_drive:
5166 drive_add(NULL, "%s", optarg);
5167 break;
5168 case QEMU_OPTION_mtdblock:
5169 drive_add(optarg, MTD_ALIAS);
5170 break;
5171 case QEMU_OPTION_sd:
5172 drive_add(optarg, SD_ALIAS);
5173 break;
5174 case QEMU_OPTION_pflash:
5175 drive_add(optarg, PFLASH_ALIAS);
5176 break;
5177 case QEMU_OPTION_snapshot:
5178 snapshot = 1;
5179 break;
5180 case QEMU_OPTION_hdachs:
5181 {
5182 const char *p;
5183 p = optarg;
5184 cyls = strtol(p, (char **)&p, 0);
5185 if (cyls < 1 || cyls > 16383)
5186 goto chs_fail;
5187 if (*p != ',')
5188 goto chs_fail;
5189 p++;
5190 heads = strtol(p, (char **)&p, 0);
5191 if (heads < 1 || heads > 16)
5192 goto chs_fail;
5193 if (*p != ',')
5194 goto chs_fail;
5195 p++;
5196 secs = strtol(p, (char **)&p, 0);
5197 if (secs < 1 || secs > 63)
5198 goto chs_fail;
5199 if (*p == ',') {
5200 p++;
5201 if (!strcmp(p, "none"))
5202 translation = BIOS_ATA_TRANSLATION_NONE;
5203 else if (!strcmp(p, "lba"))
5204 translation = BIOS_ATA_TRANSLATION_LBA;
5205 else if (!strcmp(p, "auto"))
5206 translation = BIOS_ATA_TRANSLATION_AUTO;
5207 else
5208 goto chs_fail;
5209 } else if (*p != '\0') {
5210 chs_fail:
5211 fprintf(stderr, "qemu: invalid physical CHS format\n");
5212 exit(1);
5213 }
5214 if (hda_index != -1)
5215 snprintf(drives_opt[hda_index].opt,
5216 sizeof(drives_opt[hda_index].opt),
5217 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
5218 0, cyls, heads, secs,
5219 translation == BIOS_ATA_TRANSLATION_LBA ?
5220 ",trans=lba" :
5221 translation == BIOS_ATA_TRANSLATION_NONE ?
5222 ",trans=none" : "");
5223 }
5224 break;
5225 case QEMU_OPTION_numa:
5226 if (nb_numa_nodes >= MAX_NODES) {
5227 fprintf(stderr, "qemu: too many NUMA nodes\n");
5228 exit(1);
5229 }
5230 numa_add(optarg);
5231 break;
5232 case QEMU_OPTION_nographic:
5233 display_type = DT_NOGRAPHIC;
5234 break;
5235#ifdef CONFIG_CURSES
5236 case QEMU_OPTION_curses:
5237 display_type = DT_CURSES;
5238 break;
5239#endif
5240 case QEMU_OPTION_portrait:
5241 graphic_rotate = 1;
5242 break;
5243 case QEMU_OPTION_kernel:
5244 kernel_filename = optarg;
5245 break;
5246 case QEMU_OPTION_append:
5247 kernel_cmdline = optarg;
5248 break;
5249 case QEMU_OPTION_cdrom:
5250 drive_add(optarg, CDROM_ALIAS);
5251 break;
5252 case QEMU_OPTION_boot:
5253 boot_devices = optarg;
5254 /* We just do some generic consistency checks */
5255 {
5256 /* Could easily be extended to 64 devices if needed */
5257 const char *p;
5258
5259 boot_devices_bitmap = 0;
5260 for (p = boot_devices; *p != '\0'; p++) {
5261 /* Allowed boot devices are:
5262 * a b : floppy disk drives
5263 * c ... f : IDE disk drives
5264 * g ... m : machine implementation dependant drives
5265 * n ... p : network devices
5266 * It's up to each machine implementation to check
5267 * if the given boot devices match the actual hardware
5268 * implementation and firmware features.
5269 */
5270 if (*p < 'a' || *p > 'q') {
5271 fprintf(stderr, "Invalid boot device '%c'\n", *p);
5272 exit(1);
5273 }
5274 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
5275 fprintf(stderr,
5276 "Boot device '%c' was given twice\n",*p);
5277 exit(1);
5278 }
5279 boot_devices_bitmap |= 1 << (*p - 'a');
5280 }
5281 }
5282 break;
5283 case QEMU_OPTION_fda:
5284 case QEMU_OPTION_fdb:
5285 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5286 break;
5287#ifdef TARGET_I386
5288 case QEMU_OPTION_no_fd_bootchk:
5289 fd_bootchk = 0;
5290 break;
5291#endif
5292 case QEMU_OPTION_net:
5293 if (nb_net_clients >= MAX_NET_CLIENTS) {
5294 fprintf(stderr, "qemu: too many network clients\n");
5295 exit(1);
5296 }
5297 net_clients[nb_net_clients] = optarg;
5298 nb_net_clients++;
5299 break;
5300#ifdef CONFIG_SLIRP
5301 case QEMU_OPTION_tftp:
5302 tftp_prefix = optarg;
5303 break;
5304 case QEMU_OPTION_bootp:
5305 bootp_filename = optarg;
5306 break;
5307#ifndef _WIN32
5308 case QEMU_OPTION_smb:
5309 net_slirp_smb(optarg);
5310 break;
5311#endif
5312 case QEMU_OPTION_redir:
5313 net_slirp_redir(NULL, optarg, NULL);
5314 break;
5315#endif
5316 case QEMU_OPTION_bt:
5317 if (nb_bt_opts >= MAX_BT_CMDLINE) {
5318 fprintf(stderr, "qemu: too many bluetooth options\n");
5319 exit(1);
5320 }
5321 bt_opts[nb_bt_opts++] = optarg;
5322 break;
5323#ifdef HAS_AUDIO
5324 case QEMU_OPTION_audio_help:
5325 AUD_help ();
5326 exit (0);
5327 break;
5328 case QEMU_OPTION_soundhw:
5329 select_soundhw (optarg);
5330 break;
5331#endif
5332 case QEMU_OPTION_h:
5333 help(0);
5334 break;
5335 case QEMU_OPTION_version:
5336 version();
5337 exit(0);
5338 break;
5339 case QEMU_OPTION_m: {
5340 uint64_t value;
5341 char *ptr;
5342
5343 value = strtoul(optarg, &ptr, 10);
5344 switch (*ptr) {
5345 case 0: case 'M': case 'm':
5346 value <<= 20;
5347 break;
5348 case 'G': case 'g':
5349 value <<= 30;
5350 break;
5351 default:
5352 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5353 exit(1);
5354 }
5355
5356 /* On 32-bit hosts, QEMU is limited by virtual address space */
5357 if (value > (2047 << 20)
5358#ifndef CONFIG_KQEMU
5359 && HOST_LONG_BITS == 32
5360#endif
5361 ) {
5362 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5363 exit(1);
5364 }
5365 if (value != (uint64_t)(ram_addr_t)value) {
5366 fprintf(stderr, "qemu: ram size too large\n");
5367 exit(1);
5368 }
5369 ram_size = value;
5370 break;
5371 }
5372 case QEMU_OPTION_d:
5373 {
5374 int mask;
5375 const CPULogItem *item;
5376
5377 mask = cpu_str_to_log_mask(optarg);
5378 if (!mask) {
5379 printf("Log items (comma separated):\n");
5380 for(item = cpu_log_items; item->mask != 0; item++) {
5381 printf("%-10s %s\n", item->name, item->help);
5382 }
5383 exit(1);
5384 }
5385 cpu_set_log(mask);
5386 }
5387 break;
5388 case QEMU_OPTION_s:
5389 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5390 break;
5391 case QEMU_OPTION_gdb:
5392 gdbstub_dev = optarg;
5393 break;
5394 case QEMU_OPTION_L:
5395 data_dir = optarg;
5396 break;
5397 case QEMU_OPTION_bios:
5398 bios_name = optarg;
5399 break;
5400 case QEMU_OPTION_singlestep:
5401 singlestep = 1;
5402 break;
5403 case QEMU_OPTION_S:
5404 autostart = 0;
5405 break;
5406#ifndef _WIN32
5407 case QEMU_OPTION_k:
5408 keyboard_layout = optarg;
5409 break;
5410#endif
5411 case QEMU_OPTION_localtime:
5412 rtc_utc = 0;
5413 break;
5414 case QEMU_OPTION_vga:
5415 select_vgahw (optarg);
5416 break;
5417#if defined(TARGET_PPC) || defined(TARGET_SPARC)
5418 case QEMU_OPTION_g:
5419 {
5420 const char *p;
5421 int w, h, depth;
5422 p = optarg;
5423 w = strtol(p, (char **)&p, 10);
5424 if (w <= 0) {
5425 graphic_error:
5426 fprintf(stderr, "qemu: invalid resolution or depth\n");
5427 exit(1);
5428 }
5429 if (*p != 'x')
5430 goto graphic_error;
5431 p++;
5432 h = strtol(p, (char **)&p, 10);
5433 if (h <= 0)
5434 goto graphic_error;
5435 if (*p == 'x') {
5436 p++;
5437 depth = strtol(p, (char **)&p, 10);
5438 if (depth != 8 && depth != 15 && depth != 16 &&
5439 depth != 24 && depth != 32)
5440 goto graphic_error;
5441 } else if (*p == '\0') {
5442 depth = graphic_depth;
5443 } else {
5444 goto graphic_error;
5445 }
5446
5447 graphic_width = w;
5448 graphic_height = h;
5449 graphic_depth = depth;
5450 }
5451 break;
5452#endif
5453 case QEMU_OPTION_echr:
5454 {
5455 char *r;
5456 term_escape_char = strtol(optarg, &r, 0);
5457 if (r == optarg)
5458 printf("Bad argument to echr\n");
5459 break;
5460 }
5461 case QEMU_OPTION_monitor:
5462 monitor_device = optarg;
5463 break;
5464 case QEMU_OPTION_serial:
5465 if (serial_device_index >= MAX_SERIAL_PORTS) {
5466 fprintf(stderr, "qemu: too many serial ports\n");
5467 exit(1);
5468 }
5469 serial_devices[serial_device_index] = optarg;
5470 serial_device_index++;
5471 break;
5472 case QEMU_OPTION_watchdog:
5473 i = select_watchdog(optarg);
5474 if (i > 0)
5475 exit (i == 1 ? 1 : 0);
5476 break;
5477 case QEMU_OPTION_watchdog_action:
5478 if (select_watchdog_action(optarg) == -1) {
5479 fprintf(stderr, "Unknown -watchdog-action parameter\n");
5480 exit(1);
5481 }
5482 break;
5483 case QEMU_OPTION_virtiocon:
5484 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5485 fprintf(stderr, "qemu: too many virtio consoles\n");
5486 exit(1);
5487 }
5488 virtio_consoles[virtio_console_index] = optarg;
5489 virtio_console_index++;
5490 break;
5491 case QEMU_OPTION_parallel:
5492 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5493 fprintf(stderr, "qemu: too many parallel ports\n");
5494 exit(1);
5495 }
5496 parallel_devices[parallel_device_index] = optarg;
5497 parallel_device_index++;
5498 break;
5499 case QEMU_OPTION_loadvm:
5500 loadvm = optarg;
5501 break;
5502 case QEMU_OPTION_full_screen:
5503 full_screen = 1;
5504 break;
5505#ifdef CONFIG_SDL
5506 case QEMU_OPTION_no_frame:
5507 no_frame = 1;
5508 break;
5509 case QEMU_OPTION_alt_grab:
5510 alt_grab = 1;
5511 break;
5512 case QEMU_OPTION_no_quit:
5513 no_quit = 1;
5514 break;
5515 case QEMU_OPTION_sdl:
5516 display_type = DT_SDL;
5517 break;
5518#endif
5519 case QEMU_OPTION_pidfile:
5520 pid_file = optarg;
5521 break;
5522#ifdef TARGET_I386
5523 case QEMU_OPTION_win2k_hack:
5524 win2k_install_hack = 1;
5525 break;
5526 case QEMU_OPTION_rtc_td_hack:
5527 rtc_td_hack = 1;
5528 break;
5529 case QEMU_OPTION_acpitable:
5530 if(acpi_table_add(optarg) < 0) {
5531 fprintf(stderr, "Wrong acpi table provided\n");
5532 exit(1);
5533 }
5534 break;
5535 case QEMU_OPTION_smbios:
5536 if(smbios_entry_add(optarg) < 0) {
5537 fprintf(stderr, "Wrong smbios provided\n");
5538 exit(1);
5539 }
5540 break;
5541#endif
5542#ifdef CONFIG_KQEMU
5543 case QEMU_OPTION_no_kqemu:
5544 kqemu_allowed = 0;
5545 break;
5546 case QEMU_OPTION_kernel_kqemu:
5547 kqemu_allowed = 2;
5548 break;
5549#endif
5550#ifdef CONFIG_KVM
5551 case QEMU_OPTION_enable_kvm:
5552 kvm_allowed = 1;
5553#ifdef CONFIG_KQEMU
5554 kqemu_allowed = 0;
5555#endif
5556 break;
5557#endif
5558 case QEMU_OPTION_usb:
5559 usb_enabled = 1;
5560 break;
5561 case QEMU_OPTION_usbdevice:
5562 usb_enabled = 1;
5563 if (usb_devices_index >= MAX_USB_CMDLINE) {
5564 fprintf(stderr, "Too many USB devices\n");
5565 exit(1);
5566 }
5567 usb_devices[usb_devices_index] = optarg;
5568 usb_devices_index++;
5569 break;
5570 case QEMU_OPTION_smp:
5571 smp_cpus = atoi(optarg);
5572 if (smp_cpus < 1) {
5573 fprintf(stderr, "Invalid number of CPUs\n");
5574 exit(1);
5575 }
5576 break;
5577 case QEMU_OPTION_vnc:
5578 display_type = DT_VNC;
5579 vnc_display = optarg;
5580 break;
5581#ifdef TARGET_I386
5582 case QEMU_OPTION_no_acpi:
5583 acpi_enabled = 0;
5584 break;
5585 case QEMU_OPTION_no_hpet:
5586 no_hpet = 1;
5587 break;
5588 case QEMU_OPTION_no_virtio_balloon:
5589 no_virtio_balloon = 1;
5590 break;
5591#endif
5592 case QEMU_OPTION_no_reboot:
5593 no_reboot = 1;
5594 break;
5595 case QEMU_OPTION_no_shutdown:
5596 no_shutdown = 1;
5597 break;
5598 case QEMU_OPTION_show_cursor:
5599 cursor_hide = 0;
5600 break;
5601 case QEMU_OPTION_uuid:
5602 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5603 fprintf(stderr, "Fail to parse UUID string."
5604 " Wrong format.\n");
5605 exit(1);
5606 }
5607 break;
5608#ifndef _WIN32
5609 case QEMU_OPTION_daemonize:
5610 daemonize = 1;
5611 break;
5612#endif
5613 case QEMU_OPTION_option_rom:
5614 if (nb_option_roms >= MAX_OPTION_ROMS) {
5615 fprintf(stderr, "Too many option ROMs\n");
5616 exit(1);
5617 }
5618 option_rom[nb_option_roms] = optarg;
5619 nb_option_roms++;
5620 break;
5621#if defined(TARGET_ARM) || defined(TARGET_M68K)
5622 case QEMU_OPTION_semihosting:
5623 semihosting_enabled = 1;
5624 break;
5625#endif
5626 case QEMU_OPTION_name:
5627 qemu_name = optarg;
5628 break;
5629#if defined(TARGET_SPARC) || defined(TARGET_PPC)
5630 case QEMU_OPTION_prom_env:
5631 if (nb_prom_envs >= MAX_PROM_ENVS) {
5632 fprintf(stderr, "Too many prom variables\n");
5633 exit(1);
5634 }
5635 prom_envs[nb_prom_envs] = optarg;
5636 nb_prom_envs++;
5637 break;
5638#endif
5639#ifdef TARGET_ARM
5640 case QEMU_OPTION_old_param:
5641 old_param = 1;
5642 break;
5643#endif
5644 case QEMU_OPTION_clock:
5645 configure_alarms(optarg);
5646 break;
5647 case QEMU_OPTION_startdate:
5648 {
5649 struct tm tm;
5650 time_t rtc_start_date;
5651 if (!strcmp(optarg, "now")) {
5652 rtc_date_offset = -1;
5653 } else {
5654 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5655 &tm.tm_year,
5656 &tm.tm_mon,
5657 &tm.tm_mday,
5658 &tm.tm_hour,
5659 &tm.tm_min,
5660 &tm.tm_sec) == 6) {
5661 /* OK */
5662 } else if (sscanf(optarg, "%d-%d-%d",
5663 &tm.tm_year,
5664 &tm.tm_mon,
5665 &tm.tm_mday) == 3) {
5666 tm.tm_hour = 0;
5667 tm.tm_min = 0;
5668 tm.tm_sec = 0;
5669 } else {
5670 goto date_fail;
5671 }
5672 tm.tm_year -= 1900;
5673 tm.tm_mon--;
5674 rtc_start_date = mktimegm(&tm);
5675 if (rtc_start_date == -1) {
5676 date_fail:
5677 fprintf(stderr, "Invalid date format. Valid format are:\n"
5678 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5679 exit(1);
5680 }
5681 rtc_date_offset = time(NULL) - rtc_start_date;
5682 }
5683 }
5684 break;
5685 case QEMU_OPTION_tb_size:
5686 tb_size = strtol(optarg, NULL, 0);
5687 if (tb_size < 0)
5688 tb_size = 0;
5689 break;
5690 case QEMU_OPTION_icount:
5691 use_icount = 1;
5692 if (strcmp(optarg, "auto") == 0) {
5693 icount_time_shift = -1;
5694 } else {
5695 icount_time_shift = strtol(optarg, NULL, 0);
5696 }
5697 break;
5698 case QEMU_OPTION_incoming:
5699 incoming = optarg;
5700 break;
5701#ifndef _WIN32
5702 case QEMU_OPTION_chroot:
5703 chroot_dir = optarg;
5704 break;
5705 case QEMU_OPTION_runas:
5706 run_as = optarg;
5707 break;
5708#endif
5709#ifdef CONFIG_XEN
5710 case QEMU_OPTION_xen_domid:
5711 xen_domid = atoi(optarg);
5712 break;
5713 case QEMU_OPTION_xen_create:
5714 xen_mode = XEN_CREATE;
5715 break;
5716 case QEMU_OPTION_xen_attach:
5717 xen_mode = XEN_ATTACH;
5718 break;
5719#endif
5720 }
5721 }
5722 }
5723
5724 /* If no data_dir is specified then try to find it relative to the
5725 executable path. */
5726 if (!data_dir) {
5727 data_dir = find_datadir(argv[0]);
5728 }
5729 /* If all else fails use the install patch specified when building. */
5730 if (!data_dir) {
5731 data_dir = CONFIG_QEMU_SHAREDIR;
5732 }
5733
5734#if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
5735 if (kvm_allowed && kqemu_allowed) {
5736 fprintf(stderr,
5737 "You can not enable both KVM and kqemu at the same time\n");
5738 exit(1);
5739 }
5740#endif
5741
5742 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5743 if (smp_cpus > machine->max_cpus) {
5744 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5745 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5746 machine->max_cpus);
5747 exit(1);
5748 }
5749
5750 if (display_type == DT_NOGRAPHIC) {
5751 if (serial_device_index == 0)
5752 serial_devices[0] = "stdio";
5753 if (parallel_device_index == 0)
5754 parallel_devices[0] = "null";
5755 if (strncmp(monitor_device, "vc", 2) == 0)
5756 monitor_device = "stdio";
5757 }
5758
5759#ifndef _WIN32
5760 if (daemonize) {
5761 pid_t pid;
5762
5763 if (pipe(fds) == -1)
5764 exit(1);
5765
5766 pid = fork();
5767 if (pid > 0) {
5768 uint8_t status;
5769 ssize_t len;
5770
5771 close(fds[1]);
5772
5773 again:
5774 len = read(fds[0], &status, 1);
5775 if (len == -1 && (errno == EINTR))
5776 goto again;
5777
5778 if (len != 1)
5779 exit(1);
5780 else if (status == 1) {
5781 fprintf(stderr, "Could not acquire pidfile\n");
5782 exit(1);
5783 } else
5784 exit(0);
5785 } else if (pid < 0)
5786 exit(1);
5787
5788 setsid();
5789
5790 pid = fork();
5791 if (pid > 0)
5792 exit(0);
5793 else if (pid < 0)
5794 exit(1);
5795
5796 umask(027);
5797
5798 signal(SIGTSTP, SIG_IGN);
5799 signal(SIGTTOU, SIG_IGN);
5800 signal(SIGTTIN, SIG_IGN);
5801 }
5802
5803 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5804 if (daemonize) {
5805 uint8_t status = 1;
5806 write(fds[1], &status, 1);
5807 } else
5808 fprintf(stderr, "Could not acquire pid file\n");
5809 exit(1);
5810 }
5811#endif
5812
5813#ifdef CONFIG_KQEMU
5814 if (smp_cpus > 1)
5815 kqemu_allowed = 0;
5816#endif
5817 if (qemu_init_main_loop()) {
5818 fprintf(stderr, "qemu_init_main_loop failed\n");
5819 exit(1);
5820 }
5821 linux_boot = (kernel_filename != NULL);
5822
5823 if (!linux_boot && *kernel_cmdline != '\0') {
5824 fprintf(stderr, "-append only allowed with -kernel option\n");
5825 exit(1);
5826 }
5827
5828 if (!linux_boot && initrd_filename != NULL) {
5829 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5830 exit(1);
5831 }
5832
5833 /* boot to floppy or the default cd if no hard disk defined yet */
5834 if (!boot_devices[0]) {
5835 boot_devices = "cad";
5836 }
5837 setvbuf(stdout, NULL, _IOLBF, 0);
5838
5839 init_timers();
5840 if (init_timer_alarm() < 0) {
5841 fprintf(stderr, "could not initialize alarm timer\n");
5842 exit(1);
5843 }
5844 if (use_icount && icount_time_shift < 0) {
5845 use_icount = 2;
5846 /* 125MIPS seems a reasonable initial guess at the guest speed.
5847 It will be corrected fairly quickly anyway. */
5848 icount_time_shift = 3;
5849 init_icount_adjust();
5850 }
5851
5852#ifdef _WIN32
5853 socket_init();
5854#endif
5855
5856 /* init network clients */
5857 if (nb_net_clients == 0) {
5858 /* if no clients, we use a default config */
5859 net_clients[nb_net_clients++] = "nic";
5860#ifdef CONFIG_SLIRP
5861 net_clients[nb_net_clients++] = "user";
5862#endif
5863 }
5864
5865 for(i = 0;i < nb_net_clients; i++) {
5866 if (net_client_parse(net_clients[i]) < 0)
5867 exit(1);
5868 }
5869
5870 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5871 net_set_boot_mask(net_boot);
5872
5873 net_client_check();
5874
5875 /* init the bluetooth world */
5876 for (i = 0; i < nb_bt_opts; i++)
5877 if (bt_parse(bt_opts[i]))
5878 exit(1);
5879
5880 /* init the memory */
5881 if (ram_size == 0)
5882 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5883
5884#ifdef CONFIG_KQEMU
5885 /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5886 guest ram allocation. It needs to go away. */
5887 if (kqemu_allowed) {
5888 kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024;
5889 kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5890 if (!kqemu_phys_ram_base) {
5891 fprintf(stderr, "Could not allocate physical memory\n");
5892 exit(1);
5893 }
5894 }
5895#endif
5896
5897 /* init the dynamic translator */
5898 cpu_exec_init_all(tb_size * 1024 * 1024);
5899
5900 bdrv_init();
5901
5902 /* we always create the cdrom drive, even if no disk is there */
5903
5904 if (nb_drives_opt < MAX_DRIVES)
5905 drive_add(NULL, CDROM_ALIAS);
5906
5907 /* we always create at least one floppy */
5908
5909 if (nb_drives_opt < MAX_DRIVES)
5910 drive_add(NULL, FD_ALIAS, 0);
5911
5912 /* we always create one sd slot, even if no card is in it */
5913
5914 if (nb_drives_opt < MAX_DRIVES)
5915 drive_add(NULL, SD_ALIAS);
5916
5917 /* open the virtual block devices */
5918
5919 for(i = 0; i < nb_drives_opt; i++)
5920 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5921 exit(1);
5922
5923 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5924 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5925
5926#ifndef _WIN32
5927 /* must be after terminal init, SDL library changes signal handlers */
5928 sighandler_setup();
5929#endif
5930
5931 /* Maintain compatibility with multiple stdio monitors */
5932 if (!strcmp(monitor_device,"stdio")) {
5933 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5934 const char *devname = serial_devices[i];
5935 if (devname && !strcmp(devname,"mon:stdio")) {
5936 monitor_device = NULL;
5937 break;
5938 } else if (devname && !strcmp(devname,"stdio")) {
5939 monitor_device = NULL;
5940 serial_devices[i] = "mon:stdio";
5941 break;
5942 }
5943 }
5944 }
5945
5946 if (nb_numa_nodes > 0) {
5947 int i;
5948
5949 if (nb_numa_nodes > smp_cpus) {
5950 nb_numa_nodes = smp_cpus;
5951 }
5952
5953 /* If no memory size if given for any node, assume the default case
5954 * and distribute the available memory equally across all nodes
5955 */
5956 for (i = 0; i < nb_numa_nodes; i++) {
5957 if (node_mem[i] != 0)
5958 break;
5959 }
5960 if (i == nb_numa_nodes) {
5961 uint64_t usedmem = 0;
5962
5963 /* On Linux, the each node's border has to be 8MB aligned,
5964 * the final node gets the rest.
5965 */
5966 for (i = 0; i < nb_numa_nodes - 1; i++) {
5967 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5968 usedmem += node_mem[i];
5969 }
5970 node_mem[i] = ram_size - usedmem;
5971 }
5972
5973 for (i = 0; i < nb_numa_nodes; i++) {
5974 if (node_cpumask[i] != 0)
5975 break;
5976 }
5977 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5978 * must cope with this anyway, because there are BIOSes out there in
5979 * real machines which also use this scheme.
5980 */
5981 if (i == nb_numa_nodes) {
5982 for (i = 0; i < smp_cpus; i++) {
5983 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5984 }
5985 }
5986 }
5987
5988 if (kvm_enabled()) {
5989 int ret;
5990
5991 ret = kvm_init(smp_cpus);
5992 if (ret < 0) {
5993 fprintf(stderr, "failed to initialize KVM\n");
5994 exit(1);
5995 }
5996 }
5997
5998 if (monitor_device) {
5999 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
6000 if (!monitor_hd) {
6001 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
6002 exit(1);
6003 }
6004 }
6005
6006 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6007 const char *devname = serial_devices[i];
6008 if (devname && strcmp(devname, "none")) {
6009 char label[32];
6010 snprintf(label, sizeof(label), "serial%d", i);
6011 serial_hds[i] = qemu_chr_open(label, devname, NULL);
6012 if (!serial_hds[i]) {
6013 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6014 devname);
6015 exit(1);
6016 }
6017 }
6018 }
6019
6020 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6021 const char *devname = parallel_devices[i];
6022 if (devname && strcmp(devname, "none")) {
6023 char label[32];
6024 snprintf(label, sizeof(label), "parallel%d", i);
6025 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
6026 if (!parallel_hds[i]) {
6027 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6028 devname);
6029 exit(1);
6030 }
6031 }
6032 }
6033
6034 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6035 const char *devname = virtio_consoles[i];
6036 if (devname && strcmp(devname, "none")) {
6037 char label[32];
6038 snprintf(label, sizeof(label), "virtcon%d", i);
6039 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
6040 if (!virtcon_hds[i]) {
6041 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
6042 devname);
6043 exit(1);
6044 }
6045 }
6046 }
6047
6048 module_call_init(MODULE_INIT_DEVICE);
6049
6050 machine->init(ram_size, boot_devices,
6051 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
6052
6053
6054 for (env = first_cpu; env != NULL; env = env->next_cpu) {
6055 for (i = 0; i < nb_numa_nodes; i++) {
6056 if (node_cpumask[i] & (1 << env->cpu_index)) {
6057 env->numa_node = i;
6058 }
6059 }
6060 }
6061
6062 current_machine = machine;
6063
6064 /* Set KVM's vcpu state to qemu's initial CPUState. */
6065 if (kvm_enabled()) {
6066 int ret;
6067
6068 ret = kvm_sync_vcpus();
6069 if (ret < 0) {
6070 fprintf(stderr, "failed to initialize vcpus\n");
6071 exit(1);
6072 }
6073 }
6074
6075 /* init USB devices */
6076 if (usb_enabled) {
6077 for(i = 0; i < usb_devices_index; i++) {
6078 if (usb_device_add(usb_devices[i], 0) < 0) {
6079 fprintf(stderr, "Warning: could not add USB device %s\n",
6080 usb_devices[i]);
6081 }
6082 }
6083 }
6084
6085 if (!display_state)
6086 dumb_display_init();
6087 /* just use the first displaystate for the moment */
6088 ds = display_state;
6089
6090 if (display_type == DT_DEFAULT) {
6091#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
6092 display_type = DT_SDL;
6093#else
6094 display_type = DT_VNC;
6095 vnc_display = "localhost:0,to=99";
6096 show_vnc_port = 1;
6097#endif
6098 }
6099
6100
6101 switch (display_type) {
6102 case DT_NOGRAPHIC:
6103 break;
6104#if defined(CONFIG_CURSES)
6105 case DT_CURSES:
6106 curses_display_init(ds, full_screen);
6107 break;
6108#endif
6109#if defined(CONFIG_SDL)
6110 case DT_SDL:
6111 sdl_display_init(ds, full_screen, no_frame);
6112 break;
6113#elif defined(CONFIG_COCOA)
6114 case DT_SDL:
6115 cocoa_display_init(ds, full_screen);
6116 break;
6117#endif
6118 case DT_VNC:
6119 vnc_display_init(ds);
6120 if (vnc_display_open(ds, vnc_display) < 0)
6121 exit(1);
6122
6123 if (show_vnc_port) {
6124 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6125 }
6126 break;
6127 default:
6128 break;
6129 }
6130 dpy_resize(ds);
6131
6132 dcl = ds->listeners;
6133 while (dcl != NULL) {
6134 if (dcl->dpy_refresh != NULL) {
6135 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6136 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
6137 }
6138 dcl = dcl->next;
6139 }
6140
6141 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
6142 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6143 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6144 }
6145
6146 text_consoles_set_display(display_state);
6147 qemu_chr_initial_reset();
6148
6149 if (monitor_device && monitor_hd)
6150 monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
6151
6152 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6153 const char *devname = serial_devices[i];
6154 if (devname && strcmp(devname, "none")) {
6155 if (strstart(devname, "vc", 0))
6156 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6157 }
6158 }
6159
6160 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6161 const char *devname = parallel_devices[i];
6162 if (devname && strcmp(devname, "none")) {
6163 if (strstart(devname, "vc", 0))
6164 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6165 }
6166 }
6167
6168 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6169 const char *devname = virtio_consoles[i];
6170 if (virtcon_hds[i] && devname) {
6171 if (strstart(devname, "vc", 0))
6172 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6173 }
6174 }
6175
6176 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6177 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6178 gdbstub_dev);
6179 exit(1);
6180 }
6181
6182 if (loadvm)
6183 do_loadvm(cur_mon, loadvm);
6184
6185 if (incoming) {
6186 autostart = 0; /* fixme how to deal with -daemonize */
6187 qemu_start_incoming_migration(incoming);
6188 }
6189
6190 if (autostart)
6191 vm_start();
6192
6193#ifndef _WIN32
6194 if (daemonize) {
6195 uint8_t status = 0;
6196 ssize_t len;
6197
6198 again1:
6199 len = write(fds[1], &status, 1);
6200 if (len == -1 && (errno == EINTR))
6201 goto again1;
6202
6203 if (len != 1)
6204 exit(1);
6205
6206 chdir("/");
6207 TFR(fd = open("/dev/null", O_RDWR));
6208 if (fd == -1)
6209 exit(1);
6210 }
6211
6212 if (run_as) {
6213 pwd = getpwnam(run_as);
6214 if (!pwd) {
6215 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6216 exit(1);
6217 }
6218 }
6219
6220 if (chroot_dir) {
6221 if (chroot(chroot_dir) < 0) {
6222 fprintf(stderr, "chroot failed\n");
6223 exit(1);
6224 }
6225 chdir("/");
6226 }
6227
6228 if (run_as) {
6229 if (setgid(pwd->pw_gid) < 0) {
6230 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6231 exit(1);
6232 }
6233 if (setuid(pwd->pw_uid) < 0) {
6234 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6235 exit(1);
6236 }
6237 if (setuid(0) != -1) {
6238 fprintf(stderr, "Dropping privileges failed\n");
6239 exit(1);
6240 }
6241 }
6242
6243 if (daemonize) {
6244 dup2(fd, 0);
6245 dup2(fd, 1);
6246 dup2(fd, 2);
6247
6248 close(fd);
6249 }
6250#endif
6251
6252 main_loop();
6253 quit_timers();
6254 net_cleanup();
6255
6256 return 0;
6257}
QEMU mirror