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