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