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