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