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