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