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