]> git.proxmox.com Git - qemu.git/blob - vl.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Don't exit() in config_error()
[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 = qemu_strdup("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 if (net_slirp_smb(optarg) < 0)
5102 exit(1);
5103 break;
5104 #endif
5105 case QEMU_OPTION_redir:
5106 if (net_slirp_redir(optarg) < 0)
5107 exit(1);
5108 break;
5109 #endif
5110 case QEMU_OPTION_bt:
5111 add_device_config(DEV_BT, optarg);
5112 break;
5113 #ifdef HAS_AUDIO
5114 case QEMU_OPTION_audio_help:
5115 AUD_help ();
5116 exit (0);
5117 break;
5118 case QEMU_OPTION_soundhw:
5119 select_soundhw (optarg);
5120 break;
5121 #endif
5122 case QEMU_OPTION_h:
5123 help(0);
5124 break;
5125 case QEMU_OPTION_version:
5126 version();
5127 exit(0);
5128 break;
5129 case QEMU_OPTION_m: {
5130 uint64_t value;
5131 char *ptr;
5132
5133 value = strtoul(optarg, &ptr, 10);
5134 switch (*ptr) {
5135 case 0: case 'M': case 'm':
5136 value <<= 20;
5137 break;
5138 case 'G': case 'g':
5139 value <<= 30;
5140 break;
5141 default:
5142 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5143 exit(1);
5144 }
5145
5146 /* On 32-bit hosts, QEMU is limited by virtual address space */
5147 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5148 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5149 exit(1);
5150 }
5151 if (value != (uint64_t)(ram_addr_t)value) {
5152 fprintf(stderr, "qemu: ram size too large\n");
5153 exit(1);
5154 }
5155 ram_size = value;
5156 break;
5157 }
5158 case QEMU_OPTION_d:
5159 {
5160 int mask;
5161 const CPULogItem *item;
5162
5163 mask = cpu_str_to_log_mask(optarg);
5164 if (!mask) {
5165 printf("Log items (comma separated):\n");
5166 for(item = cpu_log_items; item->mask != 0; item++) {
5167 printf("%-10s %s\n", item->name, item->help);
5168 }
5169 exit(1);
5170 }
5171 cpu_set_log(mask);
5172 }
5173 break;
5174 case QEMU_OPTION_s:
5175 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5176 break;
5177 case QEMU_OPTION_gdb:
5178 gdbstub_dev = optarg;
5179 break;
5180 case QEMU_OPTION_L:
5181 data_dir = optarg;
5182 break;
5183 case QEMU_OPTION_bios:
5184 bios_name = optarg;
5185 break;
5186 case QEMU_OPTION_singlestep:
5187 singlestep = 1;
5188 break;
5189 case QEMU_OPTION_S:
5190 autostart = 0;
5191 break;
5192 #ifndef _WIN32
5193 case QEMU_OPTION_k:
5194 keyboard_layout = optarg;
5195 break;
5196 #endif
5197 case QEMU_OPTION_localtime:
5198 rtc_utc = 0;
5199 break;
5200 case QEMU_OPTION_vga:
5201 select_vgahw (optarg);
5202 break;
5203 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5204 case QEMU_OPTION_g:
5205 {
5206 const char *p;
5207 int w, h, depth;
5208 p = optarg;
5209 w = strtol(p, (char **)&p, 10);
5210 if (w <= 0) {
5211 graphic_error:
5212 fprintf(stderr, "qemu: invalid resolution or depth\n");
5213 exit(1);
5214 }
5215 if (*p != 'x')
5216 goto graphic_error;
5217 p++;
5218 h = strtol(p, (char **)&p, 10);
5219 if (h <= 0)
5220 goto graphic_error;
5221 if (*p == 'x') {
5222 p++;
5223 depth = strtol(p, (char **)&p, 10);
5224 if (depth != 8 && depth != 15 && depth != 16 &&
5225 depth != 24 && depth != 32)
5226 goto graphic_error;
5227 } else if (*p == '\0') {
5228 depth = graphic_depth;
5229 } else {
5230 goto graphic_error;
5231 }
5232
5233 graphic_width = w;
5234 graphic_height = h;
5235 graphic_depth = depth;
5236 }
5237 break;
5238 #endif
5239 case QEMU_OPTION_echr:
5240 {
5241 char *r;
5242 term_escape_char = strtol(optarg, &r, 0);
5243 if (r == optarg)
5244 printf("Bad argument to echr\n");
5245 break;
5246 }
5247 case QEMU_OPTION_monitor:
5248 if (monitor_device_index >= MAX_MONITOR_DEVICES) {
5249 fprintf(stderr, "qemu: too many monitor devices\n");
5250 exit(1);
5251 }
5252 monitor_devices[monitor_device_index] = optarg;
5253 monitor_device_index++;
5254 break;
5255 case QEMU_OPTION_chardev:
5256 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5257 if (!opts) {
5258 fprintf(stderr, "parse error: %s\n", optarg);
5259 exit(1);
5260 }
5261 if (qemu_chr_open_opts(opts, NULL) == NULL) {
5262 exit(1);
5263 }
5264 break;
5265 case QEMU_OPTION_serial:
5266 if (serial_device_index >= MAX_SERIAL_PORTS) {
5267 fprintf(stderr, "qemu: too many serial ports\n");
5268 exit(1);
5269 }
5270 serial_devices[serial_device_index] = optarg;
5271 serial_device_index++;
5272 break;
5273 case QEMU_OPTION_watchdog:
5274 if (watchdog) {
5275 fprintf(stderr,
5276 "qemu: only one watchdog option may be given\n");
5277 return 1;
5278 }
5279 watchdog = optarg;
5280 break;
5281 case QEMU_OPTION_watchdog_action:
5282 if (select_watchdog_action(optarg) == -1) {
5283 fprintf(stderr, "Unknown -watchdog-action parameter\n");
5284 exit(1);
5285 }
5286 break;
5287 case QEMU_OPTION_virtiocon:
5288 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5289 fprintf(stderr, "qemu: too many virtio consoles\n");
5290 exit(1);
5291 }
5292 virtio_consoles[virtio_console_index] = optarg;
5293 virtio_console_index++;
5294 break;
5295 case QEMU_OPTION_parallel:
5296 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5297 fprintf(stderr, "qemu: too many parallel ports\n");
5298 exit(1);
5299 }
5300 parallel_devices[parallel_device_index] = optarg;
5301 parallel_device_index++;
5302 break;
5303 case QEMU_OPTION_loadvm:
5304 loadvm = optarg;
5305 break;
5306 case QEMU_OPTION_full_screen:
5307 full_screen = 1;
5308 break;
5309 #ifdef CONFIG_SDL
5310 case QEMU_OPTION_no_frame:
5311 no_frame = 1;
5312 break;
5313 case QEMU_OPTION_alt_grab:
5314 alt_grab = 1;
5315 break;
5316 case QEMU_OPTION_ctrl_grab:
5317 ctrl_grab = 1;
5318 break;
5319 case QEMU_OPTION_no_quit:
5320 no_quit = 1;
5321 break;
5322 case QEMU_OPTION_sdl:
5323 display_type = DT_SDL;
5324 break;
5325 #endif
5326 case QEMU_OPTION_pidfile:
5327 pid_file = optarg;
5328 break;
5329 #ifdef TARGET_I386
5330 case QEMU_OPTION_win2k_hack:
5331 win2k_install_hack = 1;
5332 break;
5333 case QEMU_OPTION_rtc_td_hack:
5334 rtc_td_hack = 1;
5335 break;
5336 case QEMU_OPTION_acpitable:
5337 if(acpi_table_add(optarg) < 0) {
5338 fprintf(stderr, "Wrong acpi table provided\n");
5339 exit(1);
5340 }
5341 break;
5342 case QEMU_OPTION_smbios:
5343 if(smbios_entry_add(optarg) < 0) {
5344 fprintf(stderr, "Wrong smbios provided\n");
5345 exit(1);
5346 }
5347 break;
5348 #endif
5349 #ifdef CONFIG_KVM
5350 case QEMU_OPTION_enable_kvm:
5351 kvm_allowed = 1;
5352 break;
5353 #endif
5354 case QEMU_OPTION_usb:
5355 usb_enabled = 1;
5356 break;
5357 case QEMU_OPTION_usbdevice:
5358 usb_enabled = 1;
5359 add_device_config(DEV_USB, optarg);
5360 break;
5361 case QEMU_OPTION_device:
5362 opts = qemu_opts_parse(&qemu_device_opts, optarg, "driver");
5363 if (!opts) {
5364 fprintf(stderr, "parse error: %s\n", optarg);
5365 exit(1);
5366 }
5367 break;
5368 case QEMU_OPTION_smp:
5369 smp_parse(optarg);
5370 if (smp_cpus < 1) {
5371 fprintf(stderr, "Invalid number of CPUs\n");
5372 exit(1);
5373 }
5374 if (max_cpus < smp_cpus) {
5375 fprintf(stderr, "maxcpus must be equal to or greater than "
5376 "smp\n");
5377 exit(1);
5378 }
5379 if (max_cpus > 255) {
5380 fprintf(stderr, "Unsupported number of maxcpus\n");
5381 exit(1);
5382 }
5383 break;
5384 case QEMU_OPTION_vnc:
5385 display_type = DT_VNC;
5386 vnc_display = optarg;
5387 break;
5388 #ifdef TARGET_I386
5389 case QEMU_OPTION_no_acpi:
5390 acpi_enabled = 0;
5391 break;
5392 case QEMU_OPTION_no_hpet:
5393 no_hpet = 1;
5394 break;
5395 case QEMU_OPTION_balloon:
5396 if (balloon_parse(optarg) < 0) {
5397 fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5398 exit(1);
5399 }
5400 break;
5401 #endif
5402 case QEMU_OPTION_no_reboot:
5403 no_reboot = 1;
5404 break;
5405 case QEMU_OPTION_no_shutdown:
5406 no_shutdown = 1;
5407 break;
5408 case QEMU_OPTION_show_cursor:
5409 cursor_hide = 0;
5410 break;
5411 case QEMU_OPTION_uuid:
5412 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5413 fprintf(stderr, "Fail to parse UUID string."
5414 " Wrong format.\n");
5415 exit(1);
5416 }
5417 break;
5418 #ifndef _WIN32
5419 case QEMU_OPTION_daemonize:
5420 daemonize = 1;
5421 break;
5422 #endif
5423 case QEMU_OPTION_option_rom:
5424 if (nb_option_roms >= MAX_OPTION_ROMS) {
5425 fprintf(stderr, "Too many option ROMs\n");
5426 exit(1);
5427 }
5428 option_rom[nb_option_roms] = optarg;
5429 nb_option_roms++;
5430 break;
5431 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5432 case QEMU_OPTION_semihosting:
5433 semihosting_enabled = 1;
5434 break;
5435 #endif
5436 case QEMU_OPTION_name:
5437 qemu_name = qemu_strdup(optarg);
5438 {
5439 char *p = strchr(qemu_name, ',');
5440 if (p != NULL) {
5441 *p++ = 0;
5442 if (strncmp(p, "process=", 8)) {
5443 fprintf(stderr, "Unknown subargument %s to -name", p);
5444 exit(1);
5445 }
5446 p += 8;
5447 set_proc_name(p);
5448 }
5449 }
5450 break;
5451 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5452 case QEMU_OPTION_prom_env:
5453 if (nb_prom_envs >= MAX_PROM_ENVS) {
5454 fprintf(stderr, "Too many prom variables\n");
5455 exit(1);
5456 }
5457 prom_envs[nb_prom_envs] = optarg;
5458 nb_prom_envs++;
5459 break;
5460 #endif
5461 #ifdef TARGET_ARM
5462 case QEMU_OPTION_old_param:
5463 old_param = 1;
5464 break;
5465 #endif
5466 case QEMU_OPTION_clock:
5467 configure_alarms(optarg);
5468 break;
5469 case QEMU_OPTION_startdate:
5470 configure_rtc_date_offset(optarg, 1);
5471 break;
5472 case QEMU_OPTION_rtc:
5473 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5474 if (!opts) {
5475 fprintf(stderr, "parse error: %s\n", optarg);
5476 exit(1);
5477 }
5478 configure_rtc(opts);
5479 break;
5480 case QEMU_OPTION_tb_size:
5481 tb_size = strtol(optarg, NULL, 0);
5482 if (tb_size < 0)
5483 tb_size = 0;
5484 break;
5485 case QEMU_OPTION_icount:
5486 use_icount = 1;
5487 if (strcmp(optarg, "auto") == 0) {
5488 icount_time_shift = -1;
5489 } else {
5490 icount_time_shift = strtol(optarg, NULL, 0);
5491 }
5492 break;
5493 case QEMU_OPTION_incoming:
5494 incoming = optarg;
5495 break;
5496 #ifndef _WIN32
5497 case QEMU_OPTION_chroot:
5498 chroot_dir = optarg;
5499 break;
5500 case QEMU_OPTION_runas:
5501 run_as = optarg;
5502 break;
5503 #endif
5504 #ifdef CONFIG_XEN
5505 case QEMU_OPTION_xen_domid:
5506 xen_domid = atoi(optarg);
5507 break;
5508 case QEMU_OPTION_xen_create:
5509 xen_mode = XEN_CREATE;
5510 break;
5511 case QEMU_OPTION_xen_attach:
5512 xen_mode = XEN_ATTACH;
5513 break;
5514 #endif
5515 }
5516 }
5517 }
5518
5519 /* If no data_dir is specified then try to find it relative to the
5520 executable path. */
5521 if (!data_dir) {
5522 data_dir = find_datadir(argv[0]);
5523 }
5524 /* If all else fails use the install patch specified when building. */
5525 if (!data_dir) {
5526 data_dir = CONFIG_QEMU_SHAREDIR;
5527 }
5528
5529 /*
5530 * Default to max_cpus = smp_cpus, in case the user doesn't
5531 * specify a max_cpus value.
5532 */
5533 if (!max_cpus)
5534 max_cpus = smp_cpus;
5535
5536 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5537 if (smp_cpus > machine->max_cpus) {
5538 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5539 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5540 machine->max_cpus);
5541 exit(1);
5542 }
5543
5544 if (display_type == DT_NOGRAPHIC) {
5545 if (serial_device_index == 0)
5546 serial_devices[0] = "stdio";
5547 if (parallel_device_index == 0)
5548 parallel_devices[0] = "null";
5549 if (strncmp(monitor_devices[0], "vc", 2) == 0) {
5550 monitor_devices[0] = "stdio";
5551 }
5552 }
5553
5554 #ifndef _WIN32
5555 if (daemonize) {
5556 pid_t pid;
5557
5558 if (pipe(fds) == -1)
5559 exit(1);
5560
5561 pid = fork();
5562 if (pid > 0) {
5563 uint8_t status;
5564 ssize_t len;
5565
5566 close(fds[1]);
5567
5568 again:
5569 len = read(fds[0], &status, 1);
5570 if (len == -1 && (errno == EINTR))
5571 goto again;
5572
5573 if (len != 1)
5574 exit(1);
5575 else if (status == 1) {
5576 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5577 exit(1);
5578 } else
5579 exit(0);
5580 } else if (pid < 0)
5581 exit(1);
5582
5583 setsid();
5584
5585 pid = fork();
5586 if (pid > 0)
5587 exit(0);
5588 else if (pid < 0)
5589 exit(1);
5590
5591 umask(027);
5592
5593 signal(SIGTSTP, SIG_IGN);
5594 signal(SIGTTOU, SIG_IGN);
5595 signal(SIGTTIN, SIG_IGN);
5596 }
5597
5598 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5599 if (daemonize) {
5600 uint8_t status = 1;
5601 write(fds[1], &status, 1);
5602 } else
5603 fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5604 exit(1);
5605 }
5606 #endif
5607
5608 if (kvm_enabled()) {
5609 int ret;
5610
5611 ret = kvm_init(smp_cpus);
5612 if (ret < 0) {
5613 fprintf(stderr, "failed to initialize KVM\n");
5614 exit(1);
5615 }
5616 }
5617
5618 if (qemu_init_main_loop()) {
5619 fprintf(stderr, "qemu_init_main_loop failed\n");
5620 exit(1);
5621 }
5622 linux_boot = (kernel_filename != NULL);
5623
5624 if (!linux_boot && *kernel_cmdline != '\0') {
5625 fprintf(stderr, "-append only allowed with -kernel option\n");
5626 exit(1);
5627 }
5628
5629 if (!linux_boot && initrd_filename != NULL) {
5630 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5631 exit(1);
5632 }
5633
5634 #ifndef _WIN32
5635 /* Win32 doesn't support line-buffering and requires size >= 2 */
5636 setvbuf(stdout, NULL, _IOLBF, 0);
5637 #endif
5638
5639 if (init_timer_alarm() < 0) {
5640 fprintf(stderr, "could not initialize alarm timer\n");
5641 exit(1);
5642 }
5643 if (use_icount && icount_time_shift < 0) {
5644 use_icount = 2;
5645 /* 125MIPS seems a reasonable initial guess at the guest speed.
5646 It will be corrected fairly quickly anyway. */
5647 icount_time_shift = 3;
5648 init_icount_adjust();
5649 }
5650
5651 #ifdef _WIN32
5652 socket_init();
5653 #endif
5654
5655 /* init network clients */
5656 if (nb_net_clients == 0) {
5657 /* if no clients, we use a default config */
5658 net_clients[nb_net_clients++] = "nic";
5659 #ifdef CONFIG_SLIRP
5660 net_clients[nb_net_clients++] = "user";
5661 #endif
5662 }
5663
5664 for(i = 0;i < nb_net_clients; i++) {
5665 if (net_client_parse(net_clients[i]) < 0)
5666 exit(1);
5667 }
5668
5669 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5670 net_set_boot_mask(net_boot);
5671
5672 net_client_check();
5673
5674 /* init the bluetooth world */
5675 if (foreach_device_config(DEV_BT, bt_parse))
5676 exit(1);
5677
5678 /* init the memory */
5679 if (ram_size == 0)
5680 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5681
5682 /* init the dynamic translator */
5683 cpu_exec_init_all(tb_size * 1024 * 1024);
5684
5685 bdrv_init();
5686
5687 /* we always create the cdrom drive, even if no disk is there */
5688 drive_add(NULL, CDROM_ALIAS);
5689
5690 /* we always create at least one floppy */
5691 drive_add(NULL, FD_ALIAS, 0);
5692
5693 /* we always create one sd slot, even if no card is in it */
5694 drive_add(NULL, SD_ALIAS);
5695
5696 /* open the virtual block devices */
5697 if (snapshot)
5698 qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5699 if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5700 exit(1);
5701
5702 vmstate_register(0, &vmstate_timers ,&timers_state);
5703 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5704
5705 /* Maintain compatibility with multiple stdio monitors */
5706 if (!strcmp(monitor_devices[0],"stdio")) {
5707 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5708 const char *devname = serial_devices[i];
5709 if (devname && !strcmp(devname,"mon:stdio")) {
5710 monitor_devices[0] = NULL;
5711 break;
5712 } else if (devname && !strcmp(devname,"stdio")) {
5713 monitor_devices[0] = NULL;
5714 serial_devices[i] = "mon:stdio";
5715 break;
5716 }
5717 }
5718 }
5719
5720 if (nb_numa_nodes > 0) {
5721 int i;
5722
5723 if (nb_numa_nodes > smp_cpus) {
5724 nb_numa_nodes = smp_cpus;
5725 }
5726
5727 /* If no memory size if given for any node, assume the default case
5728 * and distribute the available memory equally across all nodes
5729 */
5730 for (i = 0; i < nb_numa_nodes; i++) {
5731 if (node_mem[i] != 0)
5732 break;
5733 }
5734 if (i == nb_numa_nodes) {
5735 uint64_t usedmem = 0;
5736
5737 /* On Linux, the each node's border has to be 8MB aligned,
5738 * the final node gets the rest.
5739 */
5740 for (i = 0; i < nb_numa_nodes - 1; i++) {
5741 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5742 usedmem += node_mem[i];
5743 }
5744 node_mem[i] = ram_size - usedmem;
5745 }
5746
5747 for (i = 0; i < nb_numa_nodes; i++) {
5748 if (node_cpumask[i] != 0)
5749 break;
5750 }
5751 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5752 * must cope with this anyway, because there are BIOSes out there in
5753 * real machines which also use this scheme.
5754 */
5755 if (i == nb_numa_nodes) {
5756 for (i = 0; i < smp_cpus; i++) {
5757 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5758 }
5759 }
5760 }
5761
5762 for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5763 const char *devname = monitor_devices[i];
5764 if (devname && strcmp(devname, "none")) {
5765 char label[32];
5766 if (i == 0) {
5767 snprintf(label, sizeof(label), "monitor");
5768 } else {
5769 snprintf(label, sizeof(label), "monitor%d", i);
5770 }
5771 monitor_hds[i] = qemu_chr_open(label, devname, NULL);
5772 if (!monitor_hds[i]) {
5773 fprintf(stderr, "qemu: could not open monitor device '%s'\n",
5774 devname);
5775 exit(1);
5776 }
5777 }
5778 }
5779
5780 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5781 const char *devname = serial_devices[i];
5782 if (devname && strcmp(devname, "none")) {
5783 char label[32];
5784 snprintf(label, sizeof(label), "serial%d", i);
5785 serial_hds[i] = qemu_chr_open(label, devname, NULL);
5786 if (!serial_hds[i]) {
5787 fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
5788 devname, strerror(errno));
5789 exit(1);
5790 }
5791 }
5792 }
5793
5794 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5795 const char *devname = parallel_devices[i];
5796 if (devname && strcmp(devname, "none")) {
5797 char label[32];
5798 snprintf(label, sizeof(label), "parallel%d", i);
5799 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5800 if (!parallel_hds[i]) {
5801 fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
5802 devname, strerror(errno));
5803 exit(1);
5804 }
5805 }
5806 }
5807
5808 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5809 const char *devname = virtio_consoles[i];
5810 if (devname && strcmp(devname, "none")) {
5811 char label[32];
5812 snprintf(label, sizeof(label), "virtcon%d", i);
5813 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5814 if (!virtcon_hds[i]) {
5815 fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
5816 devname, strerror(errno));
5817 exit(1);
5818 }
5819 }
5820 }
5821
5822 module_call_init(MODULE_INIT_DEVICE);
5823
5824 if (watchdog) {
5825 i = select_watchdog(watchdog);
5826 if (i > 0)
5827 exit (i == 1 ? 1 : 0);
5828 }
5829
5830 if (machine->compat_props) {
5831 qdev_prop_register_compat(machine->compat_props);
5832 }
5833 machine->init(ram_size, boot_devices,
5834 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5835
5836
5837 #ifndef _WIN32
5838 /* must be after terminal init, SDL library changes signal handlers */
5839 sighandler_setup();
5840 #endif
5841
5842 for (env = first_cpu; env != NULL; env = env->next_cpu) {
5843 for (i = 0; i < nb_numa_nodes; i++) {
5844 if (node_cpumask[i] & (1 << env->cpu_index)) {
5845 env->numa_node = i;
5846 }
5847 }
5848 }
5849
5850 current_machine = machine;
5851
5852 /* init USB devices */
5853 if (usb_enabled) {
5854 if (foreach_device_config(DEV_USB, usb_parse) < 0)
5855 exit(1);
5856 }
5857
5858 /* init generic devices */
5859 if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5860 exit(1);
5861
5862 if (!display_state)
5863 dumb_display_init();
5864 /* just use the first displaystate for the moment */
5865 ds = display_state;
5866
5867 if (display_type == DT_DEFAULT) {
5868 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5869 display_type = DT_SDL;
5870 #else
5871 display_type = DT_VNC;
5872 vnc_display = "localhost:0,to=99";
5873 show_vnc_port = 1;
5874 #endif
5875 }
5876
5877
5878 switch (display_type) {
5879 case DT_NOGRAPHIC:
5880 break;
5881 #if defined(CONFIG_CURSES)
5882 case DT_CURSES:
5883 curses_display_init(ds, full_screen);
5884 break;
5885 #endif
5886 #if defined(CONFIG_SDL)
5887 case DT_SDL:
5888 sdl_display_init(ds, full_screen, no_frame);
5889 break;
5890 #elif defined(CONFIG_COCOA)
5891 case DT_SDL:
5892 cocoa_display_init(ds, full_screen);
5893 break;
5894 #endif
5895 case DT_VNC:
5896 vnc_display_init(ds);
5897 if (vnc_display_open(ds, vnc_display) < 0)
5898 exit(1);
5899
5900 if (show_vnc_port) {
5901 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
5902 }
5903 break;
5904 default:
5905 break;
5906 }
5907 dpy_resize(ds);
5908
5909 dcl = ds->listeners;
5910 while (dcl != NULL) {
5911 if (dcl->dpy_refresh != NULL) {
5912 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5913 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5914 }
5915 dcl = dcl->next;
5916 }
5917
5918 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
5919 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5920 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5921 }
5922
5923 text_consoles_set_display(display_state);
5924 qemu_chr_initial_reset();
5925
5926 for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5927 if (monitor_devices[i] && monitor_hds[i]) {
5928 monitor_init(monitor_hds[i],
5929 MONITOR_USE_READLINE |
5930 ((i == 0) ? MONITOR_IS_DEFAULT : 0));
5931 }
5932 }
5933
5934 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5935 const char *devname = serial_devices[i];
5936 if (devname && strcmp(devname, "none")) {
5937 if (strstart(devname, "vc", 0))
5938 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5939 }
5940 }
5941
5942 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5943 const char *devname = parallel_devices[i];
5944 if (devname && strcmp(devname, "none")) {
5945 if (strstart(devname, "vc", 0))
5946 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5947 }
5948 }
5949
5950 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5951 const char *devname = virtio_consoles[i];
5952 if (virtcon_hds[i] && devname) {
5953 if (strstart(devname, "vc", 0))
5954 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5955 }
5956 }
5957
5958 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5959 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5960 gdbstub_dev);
5961 exit(1);
5962 }
5963
5964 qdev_machine_creation_done();
5965
5966 rom_load_all();
5967
5968 if (loadvm) {
5969 if (load_vmstate(cur_mon, loadvm) < 0) {
5970 autostart = 0;
5971 }
5972 }
5973
5974 if (incoming) {
5975 qemu_start_incoming_migration(incoming);
5976 } else if (autostart) {
5977 vm_start();
5978 }
5979
5980 #ifndef _WIN32
5981 if (daemonize) {
5982 uint8_t status = 0;
5983 ssize_t len;
5984
5985 again1:
5986 len = write(fds[1], &status, 1);
5987 if (len == -1 && (errno == EINTR))
5988 goto again1;
5989
5990 if (len != 1)
5991 exit(1);
5992
5993 chdir("/");
5994 TFR(fd = open("/dev/null", O_RDWR));
5995 if (fd == -1)
5996 exit(1);
5997 }
5998
5999 if (run_as) {
6000 pwd = getpwnam(run_as);
6001 if (!pwd) {
6002 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6003 exit(1);
6004 }
6005 }
6006
6007 if (chroot_dir) {
6008 if (chroot(chroot_dir) < 0) {
6009 fprintf(stderr, "chroot failed\n");
6010 exit(1);
6011 }
6012 chdir("/");
6013 }
6014
6015 if (run_as) {
6016 if (setgid(pwd->pw_gid) < 0) {
6017 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6018 exit(1);
6019 }
6020 if (setuid(pwd->pw_uid) < 0) {
6021 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6022 exit(1);
6023 }
6024 if (setuid(0) != -1) {
6025 fprintf(stderr, "Dropping privileges failed\n");
6026 exit(1);
6027 }
6028 }
6029
6030 if (daemonize) {
6031 dup2(fd, 0);
6032 dup2(fd, 1);
6033 dup2(fd, 2);
6034
6035 close(fd);
6036 }
6037 #endif
6038
6039 main_loop();
6040 quit_timers();
6041 net_cleanup();
6042
6043 return 0;
6044 }
Qemu copy for testing