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