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