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