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