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 25 /* the following is needed on Linux to define ptsname() in stdlib.h */ 26 #if defined(__linux__) 27 #define _GNU_SOURCE 1 28 #endif 29 30 #include "qemu-common.h" 31 #include "hw/hw.h" 32 #include "hw/boards.h" 33 #include "hw/usb.h" 34 #include "hw/pcmcia.h" 35 #include "hw/pc.h" 36 #include "hw/audiodev.h" 37 #include "hw/isa.h" 38 #include "hw/baum.h" 39 #include "hw/goldfish_nand.h" 40 #include "net.h" 41 #include "console.h" 42 #include "sysemu.h" 43 #include "gdbstub.h" 44 #include "qemu-timer.h" 45 #include "qemu-char.h" 46 #include "blockdev.h" 47 #include "audio/audio.h" 48 49 #include "qemu_file.h" 50 #include "android/android.h" 51 #include "charpipe.h" 52 #include "modem_driver.h" 53 #include "android/gps.h" 54 #include "android/hw-kmsg.h" 55 #include "android/hw-pipe-net.h" 56 #include "android/hw-qemud.h" 57 #include "android/camera/camera-service.h" 58 #include "android/charmap.h" 59 #include "android/globals.h" 60 #include "android/utils/bufprint.h" 61 #include "android/utils/debug.h" 62 #include "android/utils/filelock.h" 63 #include "android/utils/path.h" 64 #include "android/utils/stralloc.h" 65 #include "android/utils/tempfile.h" 66 #include "android/display-core.h" 67 #include "android/utils/timezone.h" 68 #include "android/snapshot.h" 69 #include "android/opengles.h" 70 #include "targphys.h" 71 #include "tcpdump.h" 72 73 #ifdef CONFIG_MEMCHECK 74 #include "memcheck/memcheck.h" 75 #endif // CONFIG_MEMCHECK 76 77 #include <unistd.h> 78 #include <fcntl.h> 79 #include <signal.h> 80 #include <time.h> 81 #include <errno.h> 82 #include <sys/time.h> 83 #include <zlib.h> 84 85 /* Needed early for CONFIG_BSD etc. */ 86 #include "config-host.h" 87 88 #ifndef _WIN32 89 #include <libgen.h> 90 #include <sys/times.h> 91 #include <sys/wait.h> 92 #include <termios.h> 93 #include <sys/mman.h> 94 #include <sys/ioctl.h> 95 #include <sys/resource.h> 96 #include <sys/socket.h> 97 #include <netinet/in.h> 98 #include <net/if.h> 99 #if defined(__NetBSD__) 100 #include <net/if_tap.h> 101 #endif 102 #ifdef __linux__ 103 #include <linux/if_tun.h> 104 #endif 105 #include <arpa/inet.h> 106 #include <dirent.h> 107 #include <netdb.h> 108 #include <sys/select.h> 109 #ifdef CONFIG_BSD 110 #include <sys/stat.h> 111 #if defined(__FreeBSD__) || defined(__DragonFly__) 112 #include <libutil.h> 113 #else 114 #include <util.h> 115 #endif 116 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__) 117 #include <freebsd/stdlib.h> 118 #else 119 #ifdef __linux__ 120 #include <pty.h> 121 #include <malloc.h> 122 #include <linux/rtc.h> 123 124 /* For the benefit of older linux systems which don't supply it, 125 we use a local copy of hpet.h. */ 126 /* #include <linux/hpet.h> */ 127 #include "hpet.h" 128 129 #include <linux/ppdev.h> 130 #include <linux/parport.h> 131 #endif 132 #ifdef __sun__ 133 #include <sys/stat.h> 134 #include <sys/ethernet.h> 135 #include <sys/sockio.h> 136 #include <netinet/arp.h> 137 #include <netinet/in.h> 138 #include <netinet/in_systm.h> 139 #include <netinet/ip.h> 140 #include <netinet/ip_icmp.h> // must come after ip.h 141 #include <netinet/udp.h> 142 #include <netinet/tcp.h> 143 #include <net/if.h> 144 #include <syslog.h> 145 #include <stropts.h> 146 #endif 147 #endif 148 #endif 149 150 #if defined(__OpenBSD__) 151 #include <util.h> 152 #endif 153 154 #if defined(CONFIG_VDE) 155 #include <libvdeplug.h> 156 #endif 157 158 #ifdef _WIN32 159 #include <windows.h> 160 #include <malloc.h> 161 #include <sys/timeb.h> 162 #include <mmsystem.h> 163 #define getopt_long_only getopt_long 164 #define memalign(align, size) malloc(size) 165 #endif 166 167 #include "cpus.h" 168 #include "arch_init.h" 169 170 #ifdef CONFIG_COCOA 171 int qemu_main(int argc, char **argv, char **envp); 172 #undef main 173 #define main qemu_main 174 #endif /* CONFIG_COCOA */ 175 176 #include "hw/hw.h" 177 #include "hw/boards.h" 178 #include "hw/usb.h" 179 #include "hw/pcmcia.h" 180 #include "hw/pc.h" 181 #include "hw/isa.h" 182 #include "hw/baum.h" 183 #include "hw/bt.h" 184 #include "hw/watchdog.h" 185 #include "hw/smbios.h" 186 #include "hw/xen.h" 187 #include "bt-host.h" 188 #include "net.h" 189 #include "monitor.h" 190 #include "console.h" 191 #include "sysemu.h" 192 #include "gdbstub.h" 193 #include "qemu-timer.h" 194 #include "qemu-char.h" 195 #include "cache-utils.h" 196 #include "block.h" 197 #include "dma.h" 198 #include "audio/audio.h" 199 #include "migration.h" 200 #include "kvm.h" 201 #ifdef CONFIG_KVM 202 #include "kvm-android.h" 203 #endif 204 #include "balloon.h" 205 #include "android/hw-lcd.h" 206 #include "android/boot-properties.h" 207 #include "android/hw-control.h" 208 #include "android/core-init-utils.h" 209 #include "android/audio-test.h" 210 211 #ifdef CONFIG_STANDALONE_CORE 212 /* Verbose value used by the standalone emulator core (without UI) */ 213 unsigned long android_verbose; 214 #endif // CONFIG_STANDALONE_CORE 215 216 #if !defined(CONFIG_STANDALONE_CORE) 217 /* in android/qemulator.c */ 218 extern void android_emulator_set_base_port(int port); 219 #endif 220 221 #if defined(CONFIG_SKINS) && !defined(CONFIG_STANDALONE_CORE) 222 #undef main 223 #define main qemu_main 224 #endif 225 226 #include "disas.h" 227 228 #ifdef CONFIG_TRACE 229 #include "android-trace.h" 230 #endif 231 232 #include "qemu_socket.h" 233 234 #if defined(CONFIG_SLIRP) 235 #include "libslirp.h" 236 #endif 237 238 239 240 #define DEFAULT_RAM_SIZE 128 241 242 /* Max number of USB devices that can be specified on the commandline. */ 243 #define MAX_USB_CMDLINE 8 244 245 /* Max number of bluetooth switches on the commandline. */ 246 #define MAX_BT_CMDLINE 10 247 248 /* XXX: use a two level table to limit memory usage */ 249 250 static const char *data_dir; 251 const char *bios_name = NULL; 252 static void *ioport_opaque[MAX_IOPORTS]; 253 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS]; 254 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS]; 255 #ifdef MAX_DRIVES 256 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available 257 to store the VM snapshots */ 258 DriveInfo drives_table[MAX_DRIVES+1]; 259 int nb_drives; 260 #endif 261 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; 262 DisplayType display_type = DT_DEFAULT; 263 const char* keyboard_layout = NULL; 264 int64_t ticks_per_sec; 265 ram_addr_t ram_size; 266 const char *mem_path = NULL; 267 #ifdef MAP_POPULATE 268 int mem_prealloc = 0; /* force preallocation of physical target memory */ 269 #endif 270 int nb_nics; 271 NICInfo nd_table[MAX_NICS]; 272 int vm_running; 273 int autostart; 274 static int rtc_utc = 1; 275 static int rtc_date_offset = -1; /* -1 means no change */ 276 int cirrus_vga_enabled = 1; 277 int std_vga_enabled = 0; 278 int vmsvga_enabled = 0; 279 int xenfb_enabled = 0; 280 QEMUClock *rtc_clock; 281 static int full_screen = 0; 282 #ifdef CONFIG_SDL 283 static int no_frame = 0; 284 #endif 285 int no_quit = 0; 286 CharDriverState *serial_hds[MAX_SERIAL_PORTS]; 287 int serial_hds_count; 288 289 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; 290 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES]; 291 #ifdef TARGET_I386 292 int win2k_install_hack = 0; 293 int rtc_td_hack = 0; 294 #endif 295 int usb_enabled = 0; 296 int singlestep = 0; 297 int smp_cpus = 1; 298 const char *vnc_display; 299 int acpi_enabled = 1; 300 int no_hpet = 0; 301 int no_virtio_balloon = 0; 302 int fd_bootchk = 1; 303 int no_reboot = 0; 304 int no_shutdown = 0; 305 int cursor_hide = 1; 306 int graphic_rotate = 0; 307 WatchdogTimerModel *watchdog = NULL; 308 int watchdog_action = WDT_RESET; 309 const char *option_rom[MAX_OPTION_ROMS]; 310 int nb_option_roms; 311 int semihosting_enabled = 0; 312 #ifdef TARGET_ARM 313 int old_param = 0; 314 #endif 315 const char *qemu_name; 316 int alt_grab = 0; 317 #if defined(TARGET_SPARC) || defined(TARGET_PPC) 318 unsigned int nb_prom_envs = 0; 319 const char *prom_envs[MAX_PROM_ENVS]; 320 #endif 321 #ifdef MAX_DRIVES 322 int nb_drives_opt; 323 struct drive_opt drives_opt[MAX_DRIVES]; 324 #endif 325 int nb_numa_nodes; 326 uint64_t node_mem[MAX_NODES]; 327 uint64_t node_cpumask[MAX_NODES]; 328 329 static QEMUTimer *nographic_timer; 330 331 uint8_t qemu_uuid[16]; 332 333 334 int qemu_cpu_delay; 335 extern char* audio_input_source; 336 337 extern char* android_op_ports; 338 extern char* android_op_port; 339 extern char* android_op_report_console; 340 extern char* op_http_proxy; 341 // Path to the file containing specific key character map. 342 char* op_charmap_file = NULL; 343 344 /* Path to hardware initialization file passed with -android-hw option. */ 345 char* android_op_hwini = NULL; 346 347 /* Memory checker options. */ 348 char* android_op_memcheck = NULL; 349 350 /* -dns-server option value. */ 351 char* android_op_dns_server = NULL; 352 353 /* -radio option value. */ 354 char* android_op_radio = NULL; 355 356 /* -gps option value. */ 357 char* android_op_gps = NULL; 358 359 /* -audio option value. */ 360 char* android_op_audio = NULL; 361 362 /* -cpu-delay option value. */ 363 char* android_op_cpu_delay = NULL; 364 365 #ifdef CONFIG_NAND_LIMITS 366 /* -nand-limits option value. */ 367 char* android_op_nand_limits = NULL; 368 #endif // CONFIG_NAND_LIMITS 369 370 /* -netspeed option value. */ 371 char* android_op_netspeed = NULL; 372 373 /* -netdelay option value. */ 374 char* android_op_netdelay = NULL; 375 376 /* -netfast option value. */ 377 int android_op_netfast = 0; 378 379 /* -tcpdump option value. */ 380 char* android_op_tcpdump = NULL; 381 382 /* -lcd-density option value. */ 383 char* android_op_lcd_density = NULL; 384 385 /* -ui-port option value. This port will be used to report the core 386 * initialization completion. 387 */ 388 char* android_op_ui_port = NULL; 389 390 /* -ui-settings option value. This value will be passed to the UI when new UI 391 * process is attaching to the core. 392 */ 393 char* android_op_ui_settings = NULL; 394 395 /* -android-avdname option value. */ 396 char* android_op_avd_name = "unknown"; 397 398 extern int android_display_width; 399 extern int android_display_height; 400 extern int android_display_bpp; 401 402 extern void dprint( const char* format, ... ); 403 404 const char* dns_log_filename = NULL; 405 const char* drop_log_filename = NULL; 406 static int rotate_logs_requested = 0; 407 408 const char* savevm_on_exit = NULL; 409 410 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR) 411 412 /* Reports the core initialization failure to the error stdout and to the UI 413 * socket before exiting the application. 414 * Parameters that are passed to this macro are used to format the error 415 * mesage using sprintf routine. 416 */ 417 #ifdef CONFIG_ANDROID 418 #define PANIC(...) android_core_init_failure(__VA_ARGS__) 419 #else 420 #define PANIC(...) do { fprintf(stderr, __VA_ARGS__); \ 421 exit(1); \ 422 } while (0) 423 #endif // CONFIG_ANDROID 424 425 /* Exits the core during initialization. */ 426 #ifdef CONFIG_ANDROID 427 #define QEMU_EXIT(exit_code) android_core_init_exit(exit_code) 428 #else 429 #define QEMU_EXIT(exit_code) exit(exit_code) 430 #endif // CONFIG_ANDROID 431 432 /***********************************************************/ 433 /* x86 ISA bus support */ 434 435 target_phys_addr_t isa_mem_base = 0; 436 PicState2 *isa_pic; 437 438 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl; 439 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel; 440 441 static uint32_t ioport_read(int index, uint32_t address) 442 { 443 static IOPortReadFunc *default_func[3] = { 444 default_ioport_readb, 445 default_ioport_readw, 446 default_ioport_readl 447 }; 448 IOPortReadFunc *func = ioport_read_table[index][address]; 449 if (!func) 450 func = default_func[index]; 451 return func(ioport_opaque[address], address); 452 } 453 454 static void ioport_write(int index, uint32_t address, uint32_t data) 455 { 456 static IOPortWriteFunc *default_func[3] = { 457 default_ioport_writeb, 458 default_ioport_writew, 459 default_ioport_writel 460 }; 461 IOPortWriteFunc *func = ioport_write_table[index][address]; 462 if (!func) 463 func = default_func[index]; 464 func(ioport_opaque[address], address, data); 465 } 466 467 static uint32_t default_ioport_readb(void *opaque, uint32_t address) 468 { 469 #ifdef DEBUG_UNUSED_IOPORT 470 fprintf(stderr, "unused inb: port=0x%04x\n", address); 471 #endif 472 return 0xff; 473 } 474 475 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data) 476 { 477 #ifdef DEBUG_UNUSED_IOPORT 478 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data); 479 #endif 480 } 481 482 /* default is to make two byte accesses */ 483 static uint32_t default_ioport_readw(void *opaque, uint32_t address) 484 { 485 uint32_t data; 486 data = ioport_read(0, address); 487 address = (address + 1) & (MAX_IOPORTS - 1); 488 data |= ioport_read(0, address) << 8; 489 return data; 490 } 491 492 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data) 493 { 494 ioport_write(0, address, data & 0xff); 495 address = (address + 1) & (MAX_IOPORTS - 1); 496 ioport_write(0, address, (data >> 8) & 0xff); 497 } 498 499 static uint32_t default_ioport_readl(void *opaque, uint32_t address) 500 { 501 #ifdef DEBUG_UNUSED_IOPORT 502 fprintf(stderr, "unused inl: port=0x%04x\n", address); 503 #endif 504 return 0xffffffff; 505 } 506 507 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data) 508 { 509 #ifdef DEBUG_UNUSED_IOPORT 510 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data); 511 #endif 512 } 513 514 /* 515 * Sets a flag (rotate_logs_requested) to clear both the DNS and the 516 * drop logs upon receiving a SIGUSR1 signal. We need to clear the logs 517 * between the tasks that do not require restarting Qemu. 518 */ 519 void rotate_qemu_logs_handler(int signum) { 520 rotate_logs_requested = 1; 521 } 522 523 /* 524 * Resets the rotate_log_requested_flag. Normally called after qemu 525 * logs has been rotated. 526 */ 527 void reset_rotate_qemu_logs_request(void) { 528 rotate_logs_requested = 0; 529 } 530 531 /* 532 * Clears the passed qemu log when the rotate_logs_requested 533 * is set. We need to clear the logs between the tasks that do not 534 * require restarting Qemu. 535 */ 536 FILE* rotate_qemu_log(FILE* old_log_fd, const char* filename) { 537 FILE* new_log_fd = NULL; 538 if (old_log_fd) { 539 if (fclose(old_log_fd) == -1) { 540 fprintf(stderr, "Cannot close old_log fd\n"); 541 exit(errno); 542 } 543 } 544 545 if (!filename) { 546 fprintf(stderr, "The log filename to be rotated is not provided"); 547 exit(-1); 548 } 549 550 new_log_fd = fopen(filename , "wb+"); 551 if (new_log_fd == NULL) { 552 fprintf(stderr, "Cannot open the log file: %s for write.\n", 553 filename); 554 exit(1); 555 } 556 557 return new_log_fd; 558 } 559 560 /***************/ 561 /* ballooning */ 562 563 static QEMUBalloonEvent *qemu_balloon_event; 564 void *qemu_balloon_event_opaque; 565 566 void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque) 567 { 568 qemu_balloon_event = func; 569 qemu_balloon_event_opaque = opaque; 570 } 571 572 void qemu_balloon(ram_addr_t target) 573 { 574 if (qemu_balloon_event) 575 qemu_balloon_event(qemu_balloon_event_opaque, target); 576 } 577 578 ram_addr_t qemu_balloon_status(void) 579 { 580 if (qemu_balloon_event) 581 return qemu_balloon_event(qemu_balloon_event_opaque, 0); 582 return 0; 583 } 584 585 /***********************************************************/ 586 /* host time/date access */ 587 void qemu_get_timedate(struct tm *tm, int offset) 588 { 589 time_t ti; 590 struct tm *ret; 591 592 time(&ti); 593 ti += offset; 594 if (rtc_date_offset == -1) { 595 if (rtc_utc) 596 ret = gmtime(&ti); 597 else 598 ret = localtime(&ti); 599 } else { 600 ti -= rtc_date_offset; 601 ret = gmtime(&ti); 602 } 603 604 memcpy(tm, ret, sizeof(struct tm)); 605 } 606 607 int qemu_timedate_diff(struct tm *tm) 608 { 609 time_t seconds; 610 611 if (rtc_date_offset == -1) 612 if (rtc_utc) 613 seconds = mktimegm(tm); 614 else 615 seconds = mktime(tm); 616 else 617 seconds = mktimegm(tm) + rtc_date_offset; 618 619 return seconds - time(NULL); 620 } 621 622 623 #ifdef CONFIG_TRACE 624 int tbflush_requested; 625 static int exit_requested; 626 627 void start_tracing() 628 { 629 if (trace_filename == NULL) 630 return; 631 if (!tracing) { 632 fprintf(stderr,"-- start tracing --\n"); 633 start_time = Now(); 634 } 635 tracing = 1; 636 tbflush_requested = 1; 637 qemu_notify_event(); 638 } 639 640 void stop_tracing() 641 { 642 if (trace_filename == NULL) 643 return; 644 if (tracing) { 645 end_time = Now(); 646 elapsed_usecs += end_time - start_time; 647 fprintf(stderr,"-- stop tracing --\n"); 648 } 649 tracing = 0; 650 tbflush_requested = 1; 651 qemu_notify_event(); 652 } 653 654 #ifndef _WIN32 655 /* This is the handler for the SIGUSR1 and SIGUSR2 signals. 656 * SIGUSR1 turns tracing on. SIGUSR2 turns tracing off. 657 */ 658 void sigusr_handler(int sig) 659 { 660 if (sig == SIGUSR1) 661 start_tracing(); 662 else 663 stop_tracing(); 664 } 665 #endif 666 667 /* This is the handler to catch control-C so that we can exit cleanly. 668 * This is needed when tracing to flush the buffers to disk. 669 */ 670 void sigint_handler(int sig) 671 { 672 exit_requested = 1; 673 qemu_notify_event(); 674 } 675 #endif /* CONFIG_TRACE */ 676 677 678 /***********************************************************/ 679 /* Bluetooth support */ 680 static int nb_hcis; 681 static int cur_hci; 682 static struct HCIInfo *hci_table[MAX_NICS]; 683 684 static struct bt_vlan_s { 685 struct bt_scatternet_s net; 686 int id; 687 struct bt_vlan_s *next; 688 } *first_bt_vlan; 689 690 /* find or alloc a new bluetooth "VLAN" */ 691 static struct bt_scatternet_s *qemu_find_bt_vlan(int id) 692 { 693 struct bt_vlan_s **pvlan, *vlan; 694 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) { 695 if (vlan->id == id) 696 return &vlan->net; 697 } 698 vlan = qemu_mallocz(sizeof(struct bt_vlan_s)); 699 vlan->id = id; 700 pvlan = &first_bt_vlan; 701 while (*pvlan != NULL) 702 pvlan = &(*pvlan)->next; 703 *pvlan = vlan; 704 return &vlan->net; 705 } 706 707 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len) 708 { 709 } 710 711 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr) 712 { 713 return -ENOTSUP; 714 } 715 716 static struct HCIInfo null_hci = { 717 .cmd_send = null_hci_send, 718 .sco_send = null_hci_send, 719 .acl_send = null_hci_send, 720 .bdaddr_set = null_hci_addr_set, 721 }; 722 723 struct HCIInfo *qemu_next_hci(void) 724 { 725 if (cur_hci == nb_hcis) 726 return &null_hci; 727 728 return hci_table[cur_hci++]; 729 } 730 731 static struct HCIInfo *hci_init(const char *str) 732 { 733 char *endp; 734 struct bt_scatternet_s *vlan = 0; 735 736 if (!strcmp(str, "null")) 737 /* null */ 738 return &null_hci; 739 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':')) 740 /* host[:hciN] */ 741 return bt_host_hci(str[4] ? str + 5 : "hci0"); 742 else if (!strncmp(str, "hci", 3)) { 743 /* hci[,vlan=n] */ 744 if (str[3]) { 745 if (!strncmp(str + 3, ",vlan=", 6)) { 746 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0)); 747 if (*endp) 748 vlan = 0; 749 } 750 } else 751 vlan = qemu_find_bt_vlan(0); 752 if (vlan) 753 return bt_new_hci(vlan); 754 } 755 756 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str); 757 758 return 0; 759 } 760 761 static int bt_hci_parse(const char *str) 762 { 763 struct HCIInfo *hci; 764 bdaddr_t bdaddr; 765 766 if (nb_hcis >= MAX_NICS) { 767 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS); 768 return -1; 769 } 770 771 hci = hci_init(str); 772 if (!hci) 773 return -1; 774 775 bdaddr.b[0] = 0x52; 776 bdaddr.b[1] = 0x54; 777 bdaddr.b[2] = 0x00; 778 bdaddr.b[3] = 0x12; 779 bdaddr.b[4] = 0x34; 780 bdaddr.b[5] = 0x56 + nb_hcis; 781 hci->bdaddr_set(hci, bdaddr.b); 782 783 hci_table[nb_hcis++] = hci; 784 785 return 0; 786 } 787 788 static void bt_vhci_add(int vlan_id) 789 { 790 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id); 791 792 if (!vlan->slave) 793 fprintf(stderr, "qemu: warning: adding a VHCI to " 794 "an empty scatternet %i\n", vlan_id); 795 796 bt_vhci_init(bt_new_hci(vlan)); 797 } 798 799 static struct bt_device_s *bt_device_add(const char *opt) 800 { 801 struct bt_scatternet_s *vlan; 802 int vlan_id = 0; 803 char *endp = strstr(opt, ",vlan="); 804 int len = (endp ? endp - opt : strlen(opt)) + 1; 805 char devname[10]; 806 807 pstrcpy(devname, MIN(sizeof(devname), len), opt); 808 809 if (endp) { 810 vlan_id = strtol(endp + 6, &endp, 0); 811 if (*endp) { 812 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n"); 813 return 0; 814 } 815 } 816 817 vlan = qemu_find_bt_vlan(vlan_id); 818 819 if (!vlan->slave) 820 fprintf(stderr, "qemu: warning: adding a slave device to " 821 "an empty scatternet %i\n", vlan_id); 822 823 if (!strcmp(devname, "keyboard")) 824 return bt_keyboard_init(vlan); 825 826 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname); 827 return 0; 828 } 829 830 static int bt_parse(const char *opt) 831 { 832 const char *endp, *p; 833 int vlan; 834 835 if (strstart(opt, "hci", &endp)) { 836 if (!*endp || *endp == ',') { 837 if (*endp) 838 if (!strstart(endp, ",vlan=", 0)) 839 opt = endp + 1; 840 841 return bt_hci_parse(opt); 842 } 843 } else if (strstart(opt, "vhci", &endp)) { 844 if (!*endp || *endp == ',') { 845 if (*endp) { 846 if (strstart(endp, ",vlan=", &p)) { 847 vlan = strtol(p, (char **) &endp, 0); 848 if (*endp) { 849 fprintf(stderr, "qemu: bad scatternet '%s'\n", p); 850 return 1; 851 } 852 } else { 853 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1); 854 return 1; 855 } 856 } else 857 vlan = 0; 858 859 bt_vhci_add(vlan); 860 return 0; 861 } 862 } else if (strstart(opt, "device:", &endp)) 863 return !bt_device_add(endp); 864 865 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt); 866 return 1; 867 } 868 869 /***********************************************************/ 870 /* QEMU Block devices */ 871 872 #define HD_ALIAS "index=%d,media=disk" 873 #define CDROM_ALIAS "index=2,media=cdrom" 874 #define FD_ALIAS "index=%d,if=floppy" 875 #define PFLASH_ALIAS "if=pflash" 876 #define MTD_ALIAS "if=mtd" 877 #define SD_ALIAS "index=0,if=sd" 878 879 static int drive_init_func(QemuOpts *opts, void *opaque) 880 { 881 int *use_scsi = opaque; 882 int fatal_error = 0; 883 884 if (drive_init(opts, *use_scsi, &fatal_error) == NULL) { 885 if (fatal_error) 886 return 1; 887 } 888 return 0; 889 } 890 891 static int drive_enable_snapshot(QemuOpts *opts, void *opaque) 892 { 893 if (NULL == qemu_opt_get(opts, "snapshot")) { 894 qemu_opt_set(opts, "snapshot", "on"); 895 } 896 return 0; 897 } 898 899 #ifdef MAX_DRIVES 900 static int drive_opt_get_free_idx(void) 901 { 902 int index; 903 904 for (index = 0; index < MAX_DRIVES; index++) 905 if (!drives_opt[index].used) { 906 drives_opt[index].used = 1; 907 return index; 908 } 909 910 return -1; 911 } 912 913 static int drive_get_free_idx(void) 914 { 915 int index; 916 917 for (index = 0; index < MAX_DRIVES; index++) 918 if (!drives_table[index].used) { 919 drives_table[index].used = 1; 920 return index; 921 } 922 923 return -1; 924 } 925 926 int drive_add(const char *file, const char *fmt, ...) 927 { 928 va_list ap; 929 int index = drive_opt_get_free_idx(); 930 931 if (nb_drives_opt >= MAX_DRIVES || index == -1) { 932 fprintf(stderr, "qemu: too many drives\n"); 933 return -1; 934 } 935 936 drives_opt[index].file = file; 937 va_start(ap, fmt); 938 vsnprintf(drives_opt[index].opt, 939 sizeof(drives_opt[0].opt), fmt, ap); 940 va_end(ap); 941 942 nb_drives_opt++; 943 return index; 944 } 945 946 void drive_remove(int index) 947 { 948 drives_opt[index].used = 0; 949 nb_drives_opt--; 950 } 951 952 int drive_get_index(BlockInterfaceType type, int bus, int unit) 953 { 954 int index; 955 956 /* seek interface, bus and unit */ 957 958 for (index = 0; index < MAX_DRIVES; index++) 959 if (drives_table[index].type == type && 960 drives_table[index].bus == bus && 961 drives_table[index].unit == unit && 962 drives_table[index].used) 963 return index; 964 965 return -1; 966 } 967 968 int drive_get_max_bus(BlockInterfaceType type) 969 { 970 int max_bus; 971 int index; 972 973 max_bus = -1; 974 for (index = 0; index < nb_drives; index++) { 975 if(drives_table[index].type == type && 976 drives_table[index].bus > max_bus) 977 max_bus = drives_table[index].bus; 978 } 979 return max_bus; 980 } 981 982 const char *drive_get_serial(BlockDriverState *bdrv) 983 { 984 int index; 985 986 for (index = 0; index < nb_drives; index++) 987 if (drives_table[index].bdrv == bdrv) 988 return drives_table[index].serial; 989 990 return "\0"; 991 } 992 993 BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv) 994 { 995 int index; 996 997 for (index = 0; index < nb_drives; index++) 998 if (drives_table[index].bdrv == bdrv) 999 return drives_table[index].onerror; 1000 1001 return BLOCK_ERR_STOP_ENOSPC; 1002 } 1003 1004 static void bdrv_format_print(void *opaque, const char *name) 1005 { 1006 fprintf(stderr, " %s", name); 1007 } 1008 1009 void drive_uninit(BlockDriverState *bdrv) 1010 { 1011 int i; 1012 1013 for (i = 0; i < MAX_DRIVES; i++) 1014 if (drives_table[i].bdrv == bdrv) { 1015 drives_table[i].bdrv = NULL; 1016 drives_table[i].used = 0; 1017 drive_remove(drives_table[i].drive_opt_idx); 1018 nb_drives--; 1019 break; 1020 } 1021 } 1022 1023 int drive_init(struct drive_opt *arg, int snapshot, void *opaque) 1024 { 1025 char buf[128]; 1026 char file[1024]; 1027 char devname[128]; 1028 char serial[21]; 1029 const char *mediastr = ""; 1030 BlockInterfaceType type; 1031 enum { MEDIA_DISK, MEDIA_CDROM } media; 1032 int bus_id, unit_id; 1033 int cyls, heads, secs, translation; 1034 BlockDriverState *bdrv; 1035 BlockDriver *drv = NULL; 1036 QEMUMachine *machine = opaque; 1037 int max_devs; 1038 int index; 1039 int cache; 1040 int bdrv_flags, onerror; 1041 int drives_table_idx; 1042 char *str = arg->opt; 1043 static const char * const params[] = { "bus", "unit", "if", "index", 1044 "cyls", "heads", "secs", "trans", 1045 "media", "snapshot", "file", 1046 "cache", "format", "serial", "werror", 1047 NULL }; 1048 1049 if (check_params(buf, sizeof(buf), params, str) < 0) { 1050 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n", 1051 buf, str); 1052 return -1; 1053 } 1054 1055 file[0] = 0; 1056 cyls = heads = secs = 0; 1057 bus_id = 0; 1058 unit_id = -1; 1059 translation = BIOS_ATA_TRANSLATION_AUTO; 1060 index = -1; 1061 cache = 3; 1062 1063 if (machine->use_scsi) { 1064 type = IF_SCSI; 1065 max_devs = MAX_SCSI_DEVS; 1066 pstrcpy(devname, sizeof(devname), "scsi"); 1067 } else { 1068 type = IF_IDE; 1069 max_devs = MAX_IDE_DEVS; 1070 pstrcpy(devname, sizeof(devname), "ide"); 1071 } 1072 media = MEDIA_DISK; 1073 1074 /* extract parameters */ 1075 1076 if (get_param_value(buf, sizeof(buf), "bus", str)) { 1077 bus_id = strtol(buf, NULL, 0); 1078 if (bus_id < 0) { 1079 fprintf(stderr, "qemu: '%s' invalid bus id\n", str); 1080 return -1; 1081 } 1082 } 1083 1084 if (get_param_value(buf, sizeof(buf), "unit", str)) { 1085 unit_id = strtol(buf, NULL, 0); 1086 if (unit_id < 0) { 1087 fprintf(stderr, "qemu: '%s' invalid unit id\n", str); 1088 return -1; 1089 } 1090 } 1091 1092 if (get_param_value(buf, sizeof(buf), "if", str)) { 1093 pstrcpy(devname, sizeof(devname), buf); 1094 if (!strcmp(buf, "ide")) { 1095 type = IF_IDE; 1096 max_devs = MAX_IDE_DEVS; 1097 } else if (!strcmp(buf, "scsi")) { 1098 type = IF_SCSI; 1099 max_devs = MAX_SCSI_DEVS; 1100 } else if (!strcmp(buf, "floppy")) { 1101 type = IF_FLOPPY; 1102 max_devs = 0; 1103 } else if (!strcmp(buf, "pflash")) { 1104 type = IF_PFLASH; 1105 max_devs = 0; 1106 } else if (!strcmp(buf, "mtd")) { 1107 type = IF_MTD; 1108 max_devs = 0; 1109 } else if (!strcmp(buf, "sd")) { 1110 type = IF_SD; 1111 max_devs = 0; 1112 } else if (!strcmp(buf, "virtio")) { 1113 type = IF_VIRTIO; 1114 max_devs = 0; 1115 } else if (!strcmp(buf, "xen")) { 1116 type = IF_XEN; 1117 max_devs = 0; 1118 } else { 1119 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf); 1120 return -1; 1121 } 1122 } 1123 1124 if (get_param_value(buf, sizeof(buf), "index", str)) { 1125 index = strtol(buf, NULL, 0); 1126 if (index < 0) { 1127 fprintf(stderr, "qemu: '%s' invalid index\n", str); 1128 return -1; 1129 } 1130 } 1131 1132 if (get_param_value(buf, sizeof(buf), "cyls", str)) { 1133 cyls = strtol(buf, NULL, 0); 1134 } 1135 1136 if (get_param_value(buf, sizeof(buf), "heads", str)) { 1137 heads = strtol(buf, NULL, 0); 1138 } 1139 1140 if (get_param_value(buf, sizeof(buf), "secs", str)) { 1141 secs = strtol(buf, NULL, 0); 1142 } 1143 1144 if (cyls || heads || secs) { 1145 if (cyls < 1 || cyls > 16383) { 1146 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str); 1147 return -1; 1148 } 1149 if (heads < 1 || heads > 16) { 1150 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str); 1151 return -1; 1152 } 1153 if (secs < 1 || secs > 63) { 1154 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str); 1155 return -1; 1156 } 1157 } 1158 1159 if (get_param_value(buf, sizeof(buf), "trans", str)) { 1160 if (!cyls) { 1161 fprintf(stderr, 1162 "qemu: '%s' trans must be used with cyls,heads and secs\n", 1163 str); 1164 return -1; 1165 } 1166 if (!strcmp(buf, "none")) 1167 translation = BIOS_ATA_TRANSLATION_NONE; 1168 else if (!strcmp(buf, "lba")) 1169 translation = BIOS_ATA_TRANSLATION_LBA; 1170 else if (!strcmp(buf, "auto")) 1171 translation = BIOS_ATA_TRANSLATION_AUTO; 1172 else { 1173 fprintf(stderr, "qemu: '%s' invalid translation type\n", str); 1174 return -1; 1175 } 1176 } 1177 1178 if (get_param_value(buf, sizeof(buf), "media", str)) { 1179 if (!strcmp(buf, "disk")) { 1180 media = MEDIA_DISK; 1181 } else if (!strcmp(buf, "cdrom")) { 1182 if (cyls || secs || heads) { 1183 fprintf(stderr, 1184 "qemu: '%s' invalid physical CHS format\n", str); 1185 return -1; 1186 } 1187 media = MEDIA_CDROM; 1188 } else { 1189 fprintf(stderr, "qemu: '%s' invalid media\n", str); 1190 return -1; 1191 } 1192 } 1193 1194 if (get_param_value(buf, sizeof(buf), "snapshot", str)) { 1195 if (!strcmp(buf, "on")) 1196 snapshot = 1; 1197 else if (!strcmp(buf, "off")) 1198 snapshot = 0; 1199 else { 1200 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str); 1201 return -1; 1202 } 1203 } 1204 1205 if (get_param_value(buf, sizeof(buf), "cache", str)) { 1206 if (!strcmp(buf, "off") || !strcmp(buf, "none")) 1207 cache = 0; 1208 else if (!strcmp(buf, "writethrough")) 1209 cache = 1; 1210 else if (!strcmp(buf, "writeback")) 1211 cache = 2; 1212 else { 1213 fprintf(stderr, "qemu: invalid cache option\n"); 1214 return -1; 1215 } 1216 } 1217 1218 if (get_param_value(buf, sizeof(buf), "format", str)) { 1219 if (strcmp(buf, "?") == 0) { 1220 fprintf(stderr, "qemu: Supported formats:"); 1221 bdrv_iterate_format(bdrv_format_print, NULL); 1222 fprintf(stderr, "\n"); 1223 return -1; 1224 } 1225 drv = bdrv_find_format(buf); 1226 if (!drv) { 1227 fprintf(stderr, "qemu: '%s' invalid format\n", buf); 1228 return -1; 1229 } 1230 } 1231 1232 if (arg->file == NULL) 1233 get_param_value(file, sizeof(file), "file", str); 1234 else 1235 pstrcpy(file, sizeof(file), arg->file); 1236 1237 if (!get_param_value(serial, sizeof(serial), "serial", str)) 1238 memset(serial, 0, sizeof(serial)); 1239 1240 onerror = BLOCK_ERR_STOP_ENOSPC; 1241 if (get_param_value(buf, sizeof(serial), "werror", str)) { 1242 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) { 1243 fprintf(stderr, "werror is no supported by this format\n"); 1244 return -1; 1245 } 1246 if (!strcmp(buf, "ignore")) 1247 onerror = BLOCK_ERR_IGNORE; 1248 else if (!strcmp(buf, "enospc")) 1249 onerror = BLOCK_ERR_STOP_ENOSPC; 1250 else if (!strcmp(buf, "stop")) 1251 onerror = BLOCK_ERR_STOP_ANY; 1252 else if (!strcmp(buf, "report")) 1253 onerror = BLOCK_ERR_REPORT; 1254 else { 1255 fprintf(stderr, "qemu: '%s' invalid write error action\n", buf); 1256 return -1; 1257 } 1258 } 1259 1260 /* compute bus and unit according index */ 1261 1262 if (index != -1) { 1263 if (bus_id != 0 || unit_id != -1) { 1264 fprintf(stderr, 1265 "qemu: '%s' index cannot be used with bus and unit\n", str); 1266 return -1; 1267 } 1268 if (max_devs == 0) 1269 { 1270 unit_id = index; 1271 bus_id = 0; 1272 } else { 1273 unit_id = index % max_devs; 1274 bus_id = index / max_devs; 1275 } 1276 } 1277 1278 /* if user doesn't specify a unit_id, 1279 * try to find the first free 1280 */ 1281 1282 if (unit_id == -1) { 1283 unit_id = 0; 1284 while (drive_get_index(type, bus_id, unit_id) != -1) { 1285 unit_id++; 1286 if (max_devs && unit_id >= max_devs) { 1287 unit_id -= max_devs; 1288 bus_id++; 1289 } 1290 } 1291 } 1292 1293 /* check unit id */ 1294 1295 if (max_devs && unit_id >= max_devs) { 1296 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n", 1297 str, unit_id, max_devs - 1); 1298 return -1; 1299 } 1300 1301 /* 1302 * ignore multiple definitions 1303 */ 1304 1305 if (drive_get_index(type, bus_id, unit_id) != -1) 1306 return -2; 1307 1308 /* init */ 1309 1310 if (type == IF_IDE || type == IF_SCSI) 1311 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd"; 1312 if (max_devs) 1313 snprintf(buf, sizeof(buf), "%s%i%s%i", 1314 devname, bus_id, mediastr, unit_id); 1315 else 1316 snprintf(buf, sizeof(buf), "%s%s%i", 1317 devname, mediastr, unit_id); 1318 bdrv = bdrv_new(buf); 1319 drives_table_idx = drive_get_free_idx(); 1320 drives_table[drives_table_idx].bdrv = bdrv; 1321 drives_table[drives_table_idx].type = type; 1322 drives_table[drives_table_idx].bus = bus_id; 1323 drives_table[drives_table_idx].unit = unit_id; 1324 drives_table[drives_table_idx].onerror = onerror; 1325 drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt; 1326 strncpy(drives_table[drives_table_idx].serial, serial, sizeof(serial)); 1327 nb_drives++; 1328 1329 switch(type) { 1330 case IF_IDE: 1331 case IF_SCSI: 1332 case IF_XEN: 1333 switch(media) { 1334 case MEDIA_DISK: 1335 if (cyls != 0) { 1336 bdrv_set_geometry_hint(bdrv, cyls, heads, secs); 1337 bdrv_set_translation_hint(bdrv, translation); 1338 } 1339 break; 1340 case MEDIA_CDROM: 1341 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM); 1342 break; 1343 } 1344 break; 1345 case IF_SD: 1346 /* FIXME: This isn't really a floppy, but it's a reasonable 1347 approximation. */ 1348 case IF_FLOPPY: 1349 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY); 1350 break; 1351 case IF_PFLASH: 1352 case IF_MTD: 1353 case IF_VIRTIO: 1354 break; 1355 case IF_COUNT: 1356 case IF_NONE: 1357 abort(); 1358 } 1359 if (!file[0]) 1360 return -2; 1361 bdrv_flags = 0; 1362 if (snapshot) { 1363 bdrv_flags |= BDRV_O_SNAPSHOT; 1364 cache = 2; /* always use write-back with snapshot */ 1365 } 1366 if (cache == 0) /* no caching */ 1367 bdrv_flags |= BDRV_O_NOCACHE; 1368 else if (cache == 2) /* write-back */ 1369 bdrv_flags |= BDRV_O_CACHE_WB; 1370 else if (cache == 3) /* not specified */ 1371 bdrv_flags |= BDRV_O_CACHE_DEF; 1372 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) { 1373 fprintf(stderr, "qemu: could not open disk image %s\n", 1374 file); 1375 return -1; 1376 } 1377 if (bdrv_key_required(bdrv)) 1378 autostart = 0; 1379 return drives_table_idx; 1380 } 1381 #endif /* MAX_DRIVES */ 1382 1383 static void numa_add(const char *optarg) 1384 { 1385 char option[128]; 1386 char *endptr; 1387 unsigned long long value, endvalue; 1388 int nodenr; 1389 1390 optarg = get_opt_name(option, 128, optarg, ',') + 1; 1391 if (!strcmp(option, "node")) { 1392 if (get_param_value(option, 128, "nodeid", optarg) == 0) { 1393 nodenr = nb_numa_nodes; 1394 } else { 1395 nodenr = strtoull(option, NULL, 10); 1396 } 1397 1398 if (get_param_value(option, 128, "mem", optarg) == 0) { 1399 node_mem[nodenr] = 0; 1400 } else { 1401 value = strtoull(option, &endptr, 0); 1402 switch (*endptr) { 1403 case 0: case 'M': case 'm': 1404 value <<= 20; 1405 break; 1406 case 'G': case 'g': 1407 value <<= 30; 1408 break; 1409 } 1410 node_mem[nodenr] = value; 1411 } 1412 if (get_param_value(option, 128, "cpus", optarg) == 0) { 1413 node_cpumask[nodenr] = 0; 1414 } else { 1415 value = strtoull(option, &endptr, 10); 1416 if (value >= 64) { 1417 value = 63; 1418 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n"); 1419 } else { 1420 if (*endptr == '-') { 1421 endvalue = strtoull(endptr+1, &endptr, 10); 1422 if (endvalue >= 63) { 1423 endvalue = 62; 1424 fprintf(stderr, 1425 "only 63 CPUs in NUMA mode supported.\n"); 1426 } 1427 value = (1 << (endvalue + 1)) - (1 << value); 1428 } else { 1429 value = 1 << value; 1430 } 1431 } 1432 node_cpumask[nodenr] = value; 1433 } 1434 nb_numa_nodes++; 1435 } 1436 return; 1437 } 1438 1439 /***********************************************************/ 1440 /* USB devices */ 1441 1442 static USBPort *used_usb_ports; 1443 static USBPort *free_usb_ports; 1444 1445 /* ??? Maybe change this to register a hub to keep track of the topology. */ 1446 void qemu_register_usb_port(USBPort *port, void *opaque, int index, 1447 usb_attachfn attach) 1448 { 1449 port->opaque = opaque; 1450 port->index = index; 1451 port->attach = attach; 1452 port->next = free_usb_ports; 1453 free_usb_ports = port; 1454 } 1455 1456 int usb_device_add_dev(USBDevice *dev) 1457 { 1458 USBPort *port; 1459 1460 /* Find a USB port to add the device to. */ 1461 port = free_usb_ports; 1462 if (!port->next) { 1463 USBDevice *hub; 1464 1465 /* Create a new hub and chain it on. */ 1466 free_usb_ports = NULL; 1467 port->next = used_usb_ports; 1468 used_usb_ports = port; 1469 1470 hub = usb_hub_init(VM_USB_HUB_SIZE); 1471 usb_attach(port, hub); 1472 port = free_usb_ports; 1473 } 1474 1475 free_usb_ports = port->next; 1476 port->next = used_usb_ports; 1477 used_usb_ports = port; 1478 usb_attach(port, dev); 1479 return 0; 1480 } 1481 1482 #if 0 1483 static void usb_msd_password_cb(void *opaque, int err) 1484 { 1485 USBDevice *dev = opaque; 1486 1487 if (!err) 1488 usb_device_add_dev(dev); 1489 else 1490 dev->handle_destroy(dev); 1491 } 1492 #endif 1493 1494 static int usb_device_add(const char *devname, int is_hotplug) 1495 { 1496 const char *p; 1497 USBDevice *dev; 1498 1499 if (!free_usb_ports) 1500 return -1; 1501 1502 if (strstart(devname, "host:", &p)) { 1503 dev = usb_host_device_open(p); 1504 } else if (!strcmp(devname, "mouse")) { 1505 dev = usb_mouse_init(); 1506 } else if (!strcmp(devname, "tablet")) { 1507 dev = usb_tablet_init(); 1508 } else if (!strcmp(devname, "keyboard")) { 1509 dev = usb_keyboard_init(); 1510 } else if (strstart(devname, "disk:", &p)) { 1511 #if 0 1512 BlockDriverState *bs; 1513 #endif 1514 dev = usb_msd_init(p); 1515 if (!dev) 1516 return -1; 1517 #if 0 1518 bs = usb_msd_get_bdrv(dev); 1519 if (bdrv_key_required(bs)) { 1520 autostart = 0; 1521 if (is_hotplug) { 1522 monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, 1523 dev); 1524 return 0; 1525 } 1526 } 1527 } else if (!strcmp(devname, "wacom-tablet")) { 1528 dev = usb_wacom_init(); 1529 } else if (strstart(devname, "serial:", &p)) { 1530 dev = usb_serial_init(p); 1531 #ifdef CONFIG_BRLAPI 1532 } else if (!strcmp(devname, "braille")) { 1533 dev = usb_baum_init(); 1534 #endif 1535 } else if (strstart(devname, "net:", &p)) { 1536 int nic = nb_nics; 1537 1538 if (net_client_init("nic", p) < 0) 1539 return -1; 1540 nd_table[nic].model = "usb"; 1541 dev = usb_net_init(&nd_table[nic]); 1542 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) { 1543 dev = usb_bt_init(devname[2] ? hci_init(p) : 1544 bt_new_hci(qemu_find_bt_vlan(0))); 1545 #endif 1546 } else { 1547 return -1; 1548 } 1549 if (!dev) 1550 return -1; 1551 1552 return usb_device_add_dev(dev); 1553 } 1554 1555 int usb_device_del_addr(int bus_num, int addr) 1556 { 1557 USBPort *port; 1558 USBPort **lastp; 1559 USBDevice *dev; 1560 1561 if (!used_usb_ports) 1562 return -1; 1563 1564 if (bus_num != 0) 1565 return -1; 1566 1567 lastp = &used_usb_ports; 1568 port = used_usb_ports; 1569 while (port && port->dev->addr != addr) { 1570 lastp = &port->next; 1571 port = port->next; 1572 } 1573 1574 if (!port) 1575 return -1; 1576 1577 dev = port->dev; 1578 *lastp = port->next; 1579 usb_attach(port, NULL); 1580 dev->handle_destroy(dev); 1581 port->next = free_usb_ports; 1582 free_usb_ports = port; 1583 return 0; 1584 } 1585 1586 static int usb_device_del(const char *devname) 1587 { 1588 int bus_num, addr; 1589 const char *p; 1590 1591 if (strstart(devname, "host:", &p)) 1592 return usb_host_device_close(p); 1593 1594 if (!used_usb_ports) 1595 return -1; 1596 1597 p = strchr(devname, '.'); 1598 if (!p) 1599 return -1; 1600 bus_num = strtoul(devname, NULL, 0); 1601 addr = strtoul(p + 1, NULL, 0); 1602 1603 return usb_device_del_addr(bus_num, addr); 1604 } 1605 1606 void do_usb_add(Monitor *mon, const char *devname) 1607 { 1608 usb_device_add(devname, 1); 1609 } 1610 1611 void do_usb_del(Monitor *mon, const char *devname) 1612 { 1613 usb_device_del(devname); 1614 } 1615 1616 void usb_info(Monitor *mon) 1617 { 1618 USBDevice *dev; 1619 USBPort *port; 1620 const char *speed_str; 1621 1622 if (!usb_enabled) { 1623 monitor_printf(mon, "USB support not enabled\n"); 1624 return; 1625 } 1626 1627 for (port = used_usb_ports; port; port = port->next) { 1628 dev = port->dev; 1629 if (!dev) 1630 continue; 1631 switch(dev->speed) { 1632 case USB_SPEED_LOW: 1633 speed_str = "1.5"; 1634 break; 1635 case USB_SPEED_FULL: 1636 speed_str = "12"; 1637 break; 1638 case USB_SPEED_HIGH: 1639 speed_str = "480"; 1640 break; 1641 default: 1642 speed_str = "?"; 1643 break; 1644 } 1645 monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n", 1646 0, dev->addr, speed_str, dev->devname); 1647 } 1648 } 1649 1650 /***********************************************************/ 1651 /* PCMCIA/Cardbus */ 1652 1653 static struct pcmcia_socket_entry_s { 1654 PCMCIASocket *socket; 1655 struct pcmcia_socket_entry_s *next; 1656 } *pcmcia_sockets = 0; 1657 1658 void pcmcia_socket_register(PCMCIASocket *socket) 1659 { 1660 struct pcmcia_socket_entry_s *entry; 1661 1662 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s)); 1663 entry->socket = socket; 1664 entry->next = pcmcia_sockets; 1665 pcmcia_sockets = entry; 1666 } 1667 1668 void pcmcia_socket_unregister(PCMCIASocket *socket) 1669 { 1670 struct pcmcia_socket_entry_s *entry, **ptr; 1671 1672 ptr = &pcmcia_sockets; 1673 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr) 1674 if (entry->socket == socket) { 1675 *ptr = entry->next; 1676 qemu_free(entry); 1677 } 1678 } 1679 1680 void pcmcia_info(Monitor *mon) 1681 { 1682 struct pcmcia_socket_entry_s *iter; 1683 1684 if (!pcmcia_sockets) 1685 monitor_printf(mon, "No PCMCIA sockets\n"); 1686 1687 for (iter = pcmcia_sockets; iter; iter = iter->next) 1688 monitor_printf(mon, "%s: %s\n", iter->socket->slot_string, 1689 iter->socket->attached ? iter->socket->card_string : 1690 "Empty"); 1691 } 1692 1693 /***********************************************************/ 1694 /* machine registration */ 1695 1696 static QEMUMachine *first_machine = NULL; 1697 QEMUMachine *current_machine = NULL; 1698 1699 int qemu_register_machine(QEMUMachine *m) 1700 { 1701 QEMUMachine **pm; 1702 pm = &first_machine; 1703 while (*pm != NULL) 1704 pm = &(*pm)->next; 1705 m->next = NULL; 1706 *pm = m; 1707 return 0; 1708 } 1709 1710 static QEMUMachine *find_machine(const char *name) 1711 { 1712 QEMUMachine *m; 1713 1714 for(m = first_machine; m != NULL; m = m->next) { 1715 if (!strcmp(m->name, name)) 1716 return m; 1717 } 1718 return NULL; 1719 } 1720 1721 static QEMUMachine *find_default_machine(void) 1722 { 1723 QEMUMachine *m; 1724 1725 for(m = first_machine; m != NULL; m = m->next) { 1726 if (m->is_default) { 1727 return m; 1728 } 1729 } 1730 return NULL; 1731 } 1732 1733 /***********************************************************/ 1734 /* main execution loop */ 1735 1736 static void gui_update(void *opaque) 1737 { 1738 uint64_t interval = GUI_REFRESH_INTERVAL; 1739 DisplayState *ds = opaque; 1740 DisplayChangeListener *dcl = ds->listeners; 1741 1742 dpy_refresh(ds); 1743 1744 while (dcl != NULL) { 1745 if (dcl->gui_timer_interval && 1746 dcl->gui_timer_interval < interval) 1747 interval = dcl->gui_timer_interval; 1748 dcl = dcl->next; 1749 } 1750 qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock_ms(rt_clock)); 1751 } 1752 1753 static void nographic_update(void *opaque) 1754 { 1755 uint64_t interval = GUI_REFRESH_INTERVAL; 1756 1757 qemu_mod_timer(nographic_timer, interval + qemu_get_clock_ms(rt_clock)); 1758 } 1759 1760 struct vm_change_state_entry { 1761 VMChangeStateHandler *cb; 1762 void *opaque; 1763 QLIST_ENTRY (vm_change_state_entry) entries; 1764 }; 1765 1766 static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; 1767 1768 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, 1769 void *opaque) 1770 { 1771 VMChangeStateEntry *e; 1772 1773 e = qemu_mallocz(sizeof (*e)); 1774 1775 e->cb = cb; 1776 e->opaque = opaque; 1777 QLIST_INSERT_HEAD(&vm_change_state_head, e, entries); 1778 return e; 1779 } 1780 1781 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) 1782 { 1783 QLIST_REMOVE (e, entries); 1784 qemu_free (e); 1785 } 1786 1787 void vm_state_notify(int running, int reason) 1788 { 1789 VMChangeStateEntry *e; 1790 1791 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) { 1792 e->cb(e->opaque, running, reason); 1793 } 1794 } 1795 1796 void vm_start(void) 1797 { 1798 if (!vm_running) { 1799 cpu_enable_ticks(); 1800 vm_running = 1; 1801 vm_state_notify(1, 0); 1802 //qemu_rearm_alarm_timer(alarm_timer); 1803 resume_all_vcpus(); 1804 } 1805 } 1806 1807 /* reset/shutdown handler */ 1808 1809 typedef struct QEMUResetEntry { 1810 QEMUResetHandler *func; 1811 void *opaque; 1812 int order; 1813 struct QEMUResetEntry *next; 1814 } QEMUResetEntry; 1815 1816 static QEMUResetEntry *first_reset_entry; 1817 static int reset_requested; 1818 static int shutdown_requested, shutdown_signal = -1; 1819 static pid_t shutdown_pid; 1820 static int powerdown_requested; 1821 int debug_requested; 1822 static int vmstop_requested; 1823 1824 int qemu_shutdown_requested(void) 1825 { 1826 int r = shutdown_requested; 1827 shutdown_requested = 0; 1828 return r; 1829 } 1830 1831 int qemu_reset_requested(void) 1832 { 1833 int r = reset_requested; 1834 reset_requested = 0; 1835 return r; 1836 } 1837 1838 int qemu_powerdown_requested(void) 1839 { 1840 int r = powerdown_requested; 1841 powerdown_requested = 0; 1842 return r; 1843 } 1844 1845 static int qemu_debug_requested(void) 1846 { 1847 int r = debug_requested; 1848 debug_requested = 0; 1849 return r; 1850 } 1851 1852 static int qemu_vmstop_requested(void) 1853 { 1854 int r = vmstop_requested; 1855 vmstop_requested = 0; 1856 return r; 1857 } 1858 1859 void qemu_register_reset(QEMUResetHandler *func, int order, void *opaque) 1860 { 1861 QEMUResetEntry **pre, *re; 1862 1863 pre = &first_reset_entry; 1864 while (*pre != NULL && (*pre)->order >= order) { 1865 pre = &(*pre)->next; 1866 } 1867 re = qemu_mallocz(sizeof(QEMUResetEntry)); 1868 re->func = func; 1869 re->opaque = opaque; 1870 re->order = order; 1871 re->next = NULL; 1872 *pre = re; 1873 } 1874 1875 void qemu_system_reset(void) 1876 { 1877 QEMUResetEntry *re; 1878 1879 /* reset all devices */ 1880 for(re = first_reset_entry; re != NULL; re = re->next) { 1881 re->func(re->opaque); 1882 } 1883 } 1884 1885 void qemu_system_reset_request(void) 1886 { 1887 if (no_reboot) { 1888 shutdown_requested = 1; 1889 } else { 1890 reset_requested = 1; 1891 } 1892 qemu_notify_event(); 1893 } 1894 1895 void qemu_system_killed(int signal, pid_t pid) 1896 { 1897 shutdown_signal = signal; 1898 shutdown_pid = pid; 1899 qemu_system_shutdown_request(); 1900 } 1901 1902 void qemu_system_shutdown_request(void) 1903 { 1904 shutdown_requested = 1; 1905 qemu_notify_event(); 1906 } 1907 1908 void qemu_system_powerdown_request(void) 1909 { 1910 powerdown_requested = 1; 1911 qemu_notify_event(); 1912 } 1913 1914 #ifdef CONFIG_IOTHREAD 1915 static void qemu_system_vmstop_request(int reason) 1916 { 1917 vmstop_requested = reason; 1918 qemu_notify_event(); 1919 } 1920 #endif 1921 1922 void main_loop_wait(int timeout) 1923 { 1924 fd_set rfds, wfds, xfds; 1925 int ret, nfds; 1926 struct timeval tv; 1927 1928 qemu_bh_update_timeout(&timeout); 1929 1930 os_host_main_loop_wait(&timeout); 1931 1932 1933 tv.tv_sec = timeout / 1000; 1934 tv.tv_usec = (timeout % 1000) * 1000; 1935 1936 /* poll any events */ 1937 1938 /* XXX: separate device handlers from system ones */ 1939 nfds = -1; 1940 FD_ZERO(&rfds); 1941 FD_ZERO(&wfds); 1942 FD_ZERO(&xfds); 1943 qemu_iohandler_fill(&nfds, &rfds, &wfds, &xfds); 1944 if (slirp_is_inited()) { 1945 slirp_select_fill(&nfds, &rfds, &wfds, &xfds); 1946 } 1947 1948 qemu_mutex_unlock_iothread(); 1949 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv); 1950 qemu_mutex_lock_iothread(); 1951 qemu_iohandler_poll(&rfds, &wfds, &xfds, ret); 1952 if (slirp_is_inited()) { 1953 if (ret < 0) { 1954 FD_ZERO(&rfds); 1955 FD_ZERO(&wfds); 1956 FD_ZERO(&xfds); 1957 } 1958 slirp_select_poll(&rfds, &wfds, &xfds); 1959 } 1960 charpipe_poll(); 1961 1962 qemu_run_all_timers(); 1963 1964 /* Check bottom-halves last in case any of the earlier events triggered 1965 them. */ 1966 qemu_bh_poll(); 1967 1968 } 1969 1970 static int vm_can_run(void) 1971 { 1972 if (powerdown_requested) 1973 return 0; 1974 if (reset_requested) 1975 return 0; 1976 if (shutdown_requested) 1977 return 0; 1978 if (debug_requested) 1979 return 0; 1980 return 1; 1981 } 1982 1983 static void main_loop(void) 1984 { 1985 int r; 1986 1987 #ifdef CONFIG_IOTHREAD 1988 qemu_system_ready = 1; 1989 qemu_cond_broadcast(&qemu_system_cond); 1990 #endif 1991 1992 for (;;) { 1993 do { 1994 #ifdef CONFIG_PROFILER 1995 int64_t ti; 1996 #endif 1997 #ifndef CONFIG_IOTHREAD 1998 tcg_cpu_exec(); 1999 #endif 2000 #ifdef CONFIG_PROFILER 2001 ti = profile_getclock(); 2002 #endif 2003 main_loop_wait(qemu_calculate_timeout()); 2004 #ifdef CONFIG_PROFILER 2005 dev_time += profile_getclock() - ti; 2006 #endif 2007 2008 if (rotate_logs_requested) { 2009 FILE* new_dns_log_fd = rotate_qemu_log(get_slirp_dns_log_fd(), 2010 dns_log_filename); 2011 FILE* new_drop_log_fd = rotate_qemu_log(get_slirp_drop_log_fd(), 2012 drop_log_filename); 2013 slirp_dns_log_fd(new_dns_log_fd); 2014 slirp_drop_log_fd(new_drop_log_fd); 2015 reset_rotate_qemu_logs_request(); 2016 } 2017 2018 } while (vm_can_run()); 2019 2020 if (qemu_debug_requested()) 2021 vm_stop(EXCP_DEBUG); 2022 if (qemu_shutdown_requested()) { 2023 if (no_shutdown) { 2024 vm_stop(0); 2025 no_shutdown = 0; 2026 } else { 2027 if (savevm_on_exit != NULL) { 2028 do_savevm(cur_mon, savevm_on_exit); 2029 } 2030 break; 2031 } 2032 } 2033 if (qemu_reset_requested()) { 2034 pause_all_vcpus(); 2035 qemu_system_reset(); 2036 resume_all_vcpus(); 2037 } 2038 if (qemu_powerdown_requested()) 2039 qemu_system_powerdown(); 2040 if ((r = qemu_vmstop_requested())) 2041 vm_stop(r); 2042 } 2043 pause_all_vcpus(); 2044 } 2045 2046 void version(void) 2047 { 2048 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"); 2049 } 2050 2051 void qemu_help(int exitcode) 2052 { 2053 version(); 2054 printf("usage: %s [options] [disk_image]\n" 2055 "\n" 2056 "'disk_image' is a raw hard image image for IDE hard disk 0\n" 2057 "\n" 2058 #define DEF(option, opt_arg, opt_enum, opt_help) \ 2059 opt_help 2060 #define DEFHEADING(text) stringify(text) "\n" 2061 #include "qemu-options.def" 2062 #undef DEF 2063 #undef DEFHEADING 2064 #undef GEN_DOCS 2065 "\n" 2066 "During emulation, the following keys are useful:\n" 2067 "ctrl-alt-f toggle full screen\n" 2068 "ctrl-alt-n switch to virtual console 'n'\n" 2069 "ctrl-alt toggle mouse and keyboard grab\n" 2070 "\n" 2071 "When using -nographic, press 'ctrl-a h' to get some help.\n" 2072 , 2073 "qemu", 2074 DEFAULT_RAM_SIZE, 2075 #ifndef _WIN32 2076 DEFAULT_NETWORK_SCRIPT, 2077 DEFAULT_NETWORK_DOWN_SCRIPT, 2078 #endif 2079 DEFAULT_GDBSTUB_PORT, 2080 "/tmp/qemu.log"); 2081 QEMU_EXIT(exitcode); 2082 } 2083 2084 #define HAS_ARG 0x0001 2085 2086 enum { 2087 #define DEF(option, opt_arg, opt_enum, opt_help) \ 2088 opt_enum, 2089 #define DEFHEADING(text) 2090 #include "qemu-options.def" 2091 #undef DEF 2092 #undef DEFHEADING 2093 #undef GEN_DOCS 2094 }; 2095 2096 typedef struct QEMUOption { 2097 const char *name; 2098 int flags; 2099 int index; 2100 } QEMUOption; 2101 2102 static const QEMUOption qemu_options[] = { 2103 { "h", 0, QEMU_OPTION_h }, 2104 #define DEF(option, opt_arg, opt_enum, opt_help) \ 2105 { option, opt_arg, opt_enum }, 2106 #define DEFHEADING(text) 2107 #include "qemu-options.def" 2108 #undef DEF 2109 #undef DEFHEADING 2110 #undef GEN_DOCS 2111 { NULL, 0, 0 }, 2112 }; 2113 2114 static void select_vgahw (const char *p) 2115 { 2116 const char *opts; 2117 2118 cirrus_vga_enabled = 0; 2119 std_vga_enabled = 0; 2120 vmsvga_enabled = 0; 2121 xenfb_enabled = 0; 2122 if (strstart(p, "std", &opts)) { 2123 std_vga_enabled = 1; 2124 } else if (strstart(p, "cirrus", &opts)) { 2125 cirrus_vga_enabled = 1; 2126 } else if (strstart(p, "vmware", &opts)) { 2127 vmsvga_enabled = 1; 2128 } else if (strstart(p, "xenfb", &opts)) { 2129 xenfb_enabled = 1; 2130 } else if (!strstart(p, "none", &opts)) { 2131 invalid_vga: 2132 PANIC("Unknown vga type: %s", p); 2133 } 2134 while (*opts) { 2135 const char *nextopt; 2136 2137 if (strstart(opts, ",retrace=", &nextopt)) { 2138 opts = nextopt; 2139 if (strstart(opts, "dumb", &nextopt)) 2140 vga_retrace_method = VGA_RETRACE_DUMB; 2141 else if (strstart(opts, "precise", &nextopt)) 2142 vga_retrace_method = VGA_RETRACE_PRECISE; 2143 else goto invalid_vga; 2144 } else goto invalid_vga; 2145 opts = nextopt; 2146 } 2147 } 2148 2149 #define MAX_NET_CLIENTS 32 2150 2151 #ifdef _WIN32 2152 /* Look for support files in the same directory as the executable. */ 2153 static char *find_datadir(const char *argv0) 2154 { 2155 char *p; 2156 char buf[MAX_PATH]; 2157 DWORD len; 2158 2159 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1); 2160 if (len == 0) { 2161 return NULL; 2162 } 2163 2164 buf[len] = 0; 2165 p = buf + len - 1; 2166 while (p != buf && *p != '\\') 2167 p--; 2168 *p = 0; 2169 if (access(buf, R_OK) == 0) { 2170 return qemu_strdup(buf); 2171 } 2172 return NULL; 2173 } 2174 #else /* !_WIN32 */ 2175 2176 /* Similarly, return the location of the executable */ 2177 static char *find_datadir(const char *argv0) 2178 { 2179 char *p = NULL; 2180 char buf[PATH_MAX]; 2181 2182 #if defined(__linux__) 2183 { 2184 int len; 2185 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); 2186 if (len > 0) { 2187 buf[len] = 0; 2188 p = buf; 2189 } 2190 } 2191 #elif defined(__FreeBSD__) 2192 { 2193 int len; 2194 len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1); 2195 if (len > 0) { 2196 buf[len] = 0; 2197 p = buf; 2198 } 2199 } 2200 #endif 2201 /* If we don't have any way of figuring out the actual executable 2202 location then try argv[0]. */ 2203 if (!p) { 2204 p = realpath(argv0, buf); 2205 if (!p) { 2206 return NULL; 2207 } 2208 } 2209 2210 return qemu_strdup(dirname(buf)); 2211 } 2212 #endif 2213 2214 static char* 2215 qemu_find_file_with_subdir(const char* data_dir, const char* subdir, const char* name) 2216 { 2217 int len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2; 2218 char* buf = qemu_mallocz(len); 2219 2220 snprintf(buf, len, "%s/%s%s", data_dir, subdir, name); 2221 VERBOSE_PRINT(init," trying to find: %s\n", buf); 2222 if (access(buf, R_OK)) { 2223 qemu_free(buf); 2224 return NULL; 2225 } 2226 return buf; 2227 } 2228 2229 char *qemu_find_file(int type, const char *name) 2230 { 2231 const char *subdir; 2232 char *buf; 2233 2234 /* If name contains path separators then try it as a straight path. */ 2235 if ((strchr(name, '/') || strchr(name, '\\')) 2236 && access(name, R_OK) == 0) { 2237 return strdup(name); 2238 } 2239 switch (type) { 2240 case QEMU_FILE_TYPE_BIOS: 2241 subdir = ""; 2242 break; 2243 case QEMU_FILE_TYPE_KEYMAP: 2244 subdir = "keymaps/"; 2245 break; 2246 default: 2247 abort(); 2248 } 2249 buf = qemu_find_file_with_subdir(data_dir, subdir, name); 2250 #ifdef CONFIG_ANDROID 2251 if (type == QEMU_FILE_TYPE_BIOS) { 2252 /* This case corresponds to the emulator being used as part of an 2253 * SDK installation. NOTE: data_dir is really $bindir. */ 2254 if (buf == NULL) 2255 buf = qemu_find_file_with_subdir(data_dir, "lib/pc-bios/", name); 2256 /* This case corresponds to platform builds. */ 2257 if (buf == NULL) 2258 buf = qemu_find_file_with_subdir(data_dir, "../usr/share/pc-bios/", name); 2259 /* Finally, try this for standalone builds under external/qemu */ 2260 if (buf == NULL) 2261 buf = qemu_find_file_with_subdir(data_dir, "../../../prebuilt/common/pc-bios/", name); 2262 } 2263 #endif 2264 return buf; 2265 } 2266 2267 static int 2268 add_dns_server( const char* server_name ) 2269 { 2270 SockAddress addr; 2271 2272 if (sock_address_init_resolve( &addr, server_name, 55, 0 ) < 0) { 2273 fprintf(stdout, 2274 "### WARNING: can't resolve DNS server name '%s'\n", 2275 server_name ); 2276 return -1; 2277 } 2278 2279 fprintf(stderr, 2280 "DNS server name '%s' resolved to %s\n", server_name, sock_address_to_string(&addr) ); 2281 2282 if ( slirp_add_dns_server( &addr ) < 0 ) { 2283 fprintf(stderr, 2284 "### WARNING: could not add DNS server '%s' to the network stack\n", server_name); 2285 return -1; 2286 } 2287 return 0; 2288 } 2289 2290 /* Parses an integer 2291 * Pararm: 2292 * str String containing a number to be parsed. 2293 * result Passes the parsed integer in this argument 2294 * returns 0 if ok, -1 if failed 2295 */ 2296 int 2297 parse_int(const char *str, int *result) 2298 { 2299 char* r; 2300 *result = strtol(str, &r, 0); 2301 if (r == NULL || *r != '\0') 2302 return -1; 2303 2304 return 0; 2305 } 2306 2307 #ifndef _WIN32 2308 /* 2309 * Initializes the SIGUSR1 signal handler to clear Qemu logs. 2310 */ 2311 void init_qemu_clear_logs_sig() { 2312 struct sigaction act; 2313 sigfillset(&act.sa_mask); 2314 act.sa_flags = 0; 2315 act.sa_handler = rotate_qemu_logs_handler; 2316 if (sigaction(SIGUSR1, &act, NULL) == -1) { 2317 fprintf(stderr, "Failed to setup SIGUSR1 handler to clear Qemu logs\n"); 2318 exit(-1); 2319 } 2320 } 2321 #endif 2322 2323 2324 2325 /* parses a null-terminated string specifying a network port (e.g., "80") or 2326 * port range (e.g., "[6666-7000]"). In case of a single port, lport and hport 2327 * are the same. Returns 0 on success, -1 on error. */ 2328 2329 int parse_port_range(const char *str, unsigned short *lport, 2330 unsigned short *hport) { 2331 2332 unsigned int low = 0, high = 0; 2333 char *p, *arg = strdup(str); 2334 2335 if ((*arg == '[') && ((p = strrchr(arg, ']')) != NULL)) { 2336 p = arg + 1; /* skip '[' */ 2337 low = atoi(strtok(p, "-")); 2338 high = atoi(strtok(NULL, "-")); 2339 if ((low > 0) && (high > 0) && (low < high) && (high < 65535)) { 2340 *lport = low; 2341 *hport = high; 2342 } 2343 } 2344 else { 2345 low = atoi(arg); 2346 if ((0 < low) && (low < 65535)) { 2347 *lport = low; 2348 *hport = low; 2349 } 2350 } 2351 free(arg); 2352 if (low != 0) 2353 return 0; 2354 return -1; 2355 } 2356 2357 /* 2358 * Implements the generic port forwarding option 2359 */ 2360 void 2361 net_slirp_forward(const char *optarg) 2362 { 2363 /* 2364 * we expect the following format: 2365 * dst_net:dst_mask:dst_port:redirect_ip:redirect_port OR 2366 * dst_net:dst_mask:[dp_range_start-dp_range_end]:redirect_ip:redirect_port 2367 */ 2368 char *argument = strdup(optarg), *p = argument; 2369 char *dst_net, *dst_mask, *dst_port; 2370 char *redirect_ip, *redirect_port; 2371 uint32_t dnet, dmask, rip; 2372 unsigned short dlport, dhport, rport; 2373 2374 2375 dst_net = strtok(p, ":"); 2376 dst_mask = strtok(NULL, ":"); 2377 dst_port = strtok(NULL, ":"); 2378 redirect_ip = strtok(NULL, ":"); 2379 redirect_port = strtok(NULL, ":"); 2380 2381 if (dst_net == NULL || dst_mask == NULL || dst_port == NULL || 2382 redirect_ip == NULL || redirect_port == NULL) { 2383 fprintf(stderr, 2384 "Invalid argument for -net-forward, we expect " 2385 "dst_net:dst_mask:dst_port:redirect_ip:redirect_port or " 2386 "dst_net:dst_mask:[dp_range_start-dp_range_end]" 2387 ":redirect_ip:redirect_port: %s\n", 2388 optarg); 2389 exit(1); 2390 } 2391 2392 /* inet_strtoip converts dotted address to host byte order */ 2393 if (inet_strtoip(dst_net, &dnet) == -1) { 2394 fprintf(stderr, "Invalid destination IP net: %s\n", dst_net); 2395 exit(1); 2396 } 2397 if (inet_strtoip(dst_mask, &dmask) == -1) { 2398 fprintf(stderr, "Invalid destination IP mask: %s\n", dst_mask); 2399 exit(1); 2400 } 2401 if (inet_strtoip(redirect_ip, &rip) == -1) { 2402 fprintf(stderr, "Invalid redirect IP address: %s\n", redirect_ip); 2403 exit(1); 2404 } 2405 2406 if (parse_port_range(dst_port, &dlport, &dhport) == -1) { 2407 fprintf(stderr, "Invalid destination port or port range\n"); 2408 exit(1); 2409 } 2410 2411 rport = atoi(redirect_port); 2412 if (!rport) { 2413 fprintf(stderr, "Invalid redirect port: %s\n", redirect_port); 2414 exit(1); 2415 } 2416 2417 dnet &= dmask; 2418 2419 slirp_add_net_forward(dnet, dmask, dlport, dhport, 2420 rip, rport); 2421 2422 free(argument); 2423 } 2424 2425 2426 /* Parses an -allow-tcp or -allow-udp argument and inserts a corresponding 2427 * entry in the allows list */ 2428 void 2429 slirp_allow(const char *optarg, u_int8_t proto) 2430 { 2431 /* 2432 * we expect the following format: 2433 * dst_ip:dst_port OR dst_ip:[dst_lport-dst_hport] 2434 */ 2435 char *argument = strdup(optarg), *p = argument; 2436 char *dst_ip_str, *dst_port_str; 2437 uint32_t dst_ip; 2438 unsigned short dst_lport, dst_hport; 2439 2440 dst_ip_str = strtok(p, ":"); 2441 dst_port_str = strtok(NULL, ":"); 2442 2443 if (dst_ip_str == NULL || dst_port_str == NULL) { 2444 fprintf(stderr, 2445 "Invalid argument %s for -allow. We expect " 2446 "dst_ip:dst_port or dst_ip:[dst_lport-dst_hport]\n", 2447 optarg); 2448 exit(1); 2449 } 2450 2451 if (inet_strtoip(dst_ip_str, &dst_ip) == -1) { 2452 fprintf(stderr, "Invalid destination IP address: %s\n", dst_ip_str); 2453 exit(1); 2454 } 2455 if (parse_port_range(dst_port_str, &dst_lport, &dst_hport) == -1) { 2456 fprintf(stderr, "Invalid destination port or port range\n"); 2457 exit(1); 2458 } 2459 2460 slirp_add_allow(dst_ip, dst_lport, dst_hport, proto); 2461 2462 free(argument); 2463 } 2464 2465 /* Add a serial device at a given location in the emulated hardware table. 2466 * On failure, this function aborts the program with an error message. 2467 */ 2468 static void 2469 serial_hds_add_at(int index, const char* devname) 2470 { 2471 char label[32]; 2472 2473 if (!devname || !strcmp(devname,"none")) 2474 return; 2475 2476 if (index >= MAX_SERIAL_PORTS) { 2477 PANIC("qemu: invalid serial index for %s (%d >= %d)", 2478 devname, index, MAX_SERIAL_PORTS); 2479 } 2480 if (serial_hds[index] != NULL) { 2481 PANIC("qemu: invalid serial index for %s (%d: already taken!)", 2482 devname, index); 2483 } 2484 snprintf(label, sizeof(label), "serial%d", index); 2485 serial_hds[index] = qemu_chr_open(label, devname, NULL); 2486 if (!serial_hds[index]) { 2487 PANIC("qemu: could not open serial device '%s'", devname); 2488 } 2489 } 2490 2491 2492 /* Find a free slot in the emulated serial device table, and register 2493 * it. Return the allocated table index. 2494 */ 2495 static int 2496 serial_hds_add(const char* devname) 2497 { 2498 int index; 2499 2500 /* Find first free slot */ 2501 for (index = 0; index < MAX_SERIAL_PORTS; index++) { 2502 if (serial_hds[index] == NULL) { 2503 serial_hds_add_at(index, devname); 2504 return index; 2505 } 2506 } 2507 2508 PANIC("qemu: too many serial devices registered (%d)", index); 2509 return -1; /* shouldn't happen */ 2510 } 2511 2512 int main(int argc, char **argv, char **envp) 2513 { 2514 const char *gdbstub_dev = NULL; 2515 uint32_t boot_devices_bitmap = 0; 2516 int i; 2517 int snapshot, linux_boot, net_boot; 2518 const char *icount_option = NULL; 2519 const char *initrd_filename; 2520 const char *kernel_filename, *kernel_cmdline; 2521 const char *boot_devices = ""; 2522 DisplayState *ds; 2523 DisplayChangeListener *dcl; 2524 int cyls, heads, secs, translation; 2525 QemuOpts *hda_opts = NULL; 2526 QemuOpts *hdb_opts = NULL; 2527 const char *net_clients[MAX_NET_CLIENTS]; 2528 int nb_net_clients; 2529 const char *bt_opts[MAX_BT_CMDLINE]; 2530 int nb_bt_opts; 2531 int optind; 2532 const char *r, *optarg; 2533 CharDriverState *monitor_hd = NULL; 2534 const char *monitor_device; 2535 const char *serial_devices[MAX_SERIAL_PORTS]; 2536 int serial_device_index; 2537 const char *parallel_devices[MAX_PARALLEL_PORTS]; 2538 int parallel_device_index; 2539 const char *virtio_consoles[MAX_VIRTIO_CONSOLES]; 2540 int virtio_console_index; 2541 const char *loadvm = NULL; 2542 QEMUMachine *machine; 2543 const char *cpu_model; 2544 const char *usb_devices[MAX_USB_CMDLINE]; 2545 int usb_devices_index; 2546 int tb_size; 2547 const char *pid_file = NULL; 2548 const char *incoming = NULL; 2549 CPUState *env; 2550 int show_vnc_port = 0; 2551 IniFile* hw_ini = NULL; 2552 STRALLOC_DEFINE(kernel_params); 2553 STRALLOC_DEFINE(kernel_config); 2554 int dns_count = 0; 2555 2556 /* Initialize sockets before anything else, so we can properly report 2557 * initialization failures back to the UI. */ 2558 #ifdef _WIN32 2559 socket_init(); 2560 #endif 2561 2562 init_clocks(); 2563 2564 qemu_cache_utils_init(envp); 2565 2566 QLIST_INIT (&vm_change_state_head); 2567 os_setup_early_signal_handling(); 2568 2569 module_call_init(MODULE_INIT_MACHINE); 2570 machine = find_default_machine(); 2571 cpu_model = NULL; 2572 initrd_filename = NULL; 2573 ram_size = 0; 2574 snapshot = 0; 2575 kernel_filename = NULL; 2576 kernel_cmdline = ""; 2577 2578 cyls = heads = secs = 0; 2579 translation = BIOS_ATA_TRANSLATION_AUTO; 2580 monitor_device = "vc:80Cx24C"; 2581 2582 serial_devices[0] = "vc:80Cx24C"; 2583 for(i = 1; i < MAX_SERIAL_PORTS; i++) 2584 serial_devices[i] = NULL; 2585 serial_device_index = 0; 2586 2587 parallel_devices[0] = "vc:80Cx24C"; 2588 for(i = 1; i < MAX_PARALLEL_PORTS; i++) 2589 parallel_devices[i] = NULL; 2590 parallel_device_index = 0; 2591 2592 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) 2593 virtio_consoles[i] = NULL; 2594 virtio_console_index = 0; 2595 2596 for (i = 0; i < MAX_NODES; i++) { 2597 node_mem[i] = 0; 2598 node_cpumask[i] = 0; 2599 } 2600 2601 usb_devices_index = 0; 2602 2603 nb_net_clients = 0; 2604 nb_bt_opts = 0; 2605 #ifdef MAX_DRIVES 2606 nb_drives = 0; 2607 nb_drives_opt = 0; 2608 #endif 2609 nb_numa_nodes = 0; 2610 2611 nb_nics = 0; 2612 2613 tb_size = 0; 2614 autostart= 1; 2615 2616 register_watchdogs(); 2617 2618 /* Initialize boot properties. */ 2619 boot_property_init_service(); 2620 android_hw_control_init(); 2621 android_net_pipes_init(); 2622 2623 #ifdef CONFIG_KVM 2624 /* By default, force auto-detection for kvm */ 2625 kvm_allowed = -1; 2626 #endif 2627 2628 optind = 1; 2629 for(;;) { 2630 if (optind >= argc) 2631 break; 2632 r = argv[optind]; 2633 if (r[0] != '-') { 2634 hda_opts = drive_add(argv[optind++], HD_ALIAS, 0); 2635 } else { 2636 const QEMUOption *popt; 2637 2638 optind++; 2639 /* Treat --foo the same as -foo. */ 2640 if (r[1] == '-') 2641 r++; 2642 popt = qemu_options; 2643 for(;;) { 2644 if (!popt->name) { 2645 PANIC("%s: invalid option -- '%s'", 2646 argv[0], r); 2647 } 2648 if (!strcmp(popt->name, r + 1)) 2649 break; 2650 popt++; 2651 } 2652 if (popt->flags & HAS_ARG) { 2653 if (optind >= argc) { 2654 PANIC("%s: option '%s' requires an argument", 2655 argv[0], r); 2656 } 2657 optarg = argv[optind++]; 2658 } else { 2659 optarg = NULL; 2660 } 2661 2662 switch(popt->index) { 2663 case QEMU_OPTION_M: 2664 machine = find_machine(optarg); 2665 if (!machine) { 2666 QEMUMachine *m; 2667 printf("Supported machines are:\n"); 2668 for(m = first_machine; m != NULL; m = m->next) { 2669 printf("%-10s %s%s\n", 2670 m->name, m->desc, 2671 m->is_default ? " (default)" : ""); 2672 } 2673 if (*optarg != '?') { 2674 PANIC("Invalid machine parameter: %s", 2675 optarg); 2676 } else { 2677 QEMU_EXIT(0); 2678 } 2679 } 2680 break; 2681 case QEMU_OPTION_cpu: 2682 /* hw initialization will check this */ 2683 if (*optarg == '?') { 2684 /* XXX: implement xxx_cpu_list for targets that still miss it */ 2685 #if defined(cpu_list) 2686 cpu_list(stdout, &fprintf); 2687 #endif 2688 QEMU_EXIT(0); 2689 } else { 2690 cpu_model = optarg; 2691 } 2692 break; 2693 case QEMU_OPTION_initrd: 2694 initrd_filename = optarg; 2695 break; 2696 case QEMU_OPTION_hda: 2697 if (cyls == 0) 2698 hda_opts = drive_add(optarg, HD_ALIAS, 0); 2699 else 2700 hda_opts = drive_add(optarg, HD_ALIAS 2701 ",cyls=%d,heads=%d,secs=%d%s", 2702 0, cyls, heads, secs, 2703 translation == BIOS_ATA_TRANSLATION_LBA ? 2704 ",trans=lba" : 2705 translation == BIOS_ATA_TRANSLATION_NONE ? 2706 ",trans=none" : ""); 2707 break; 2708 case QEMU_OPTION_hdb: 2709 hdb_opts = drive_add(optarg, HD_ALIAS, 1); 2710 break; 2711 2712 case QEMU_OPTION_hdc: 2713 case QEMU_OPTION_hdd: 2714 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda); 2715 break; 2716 case QEMU_OPTION_drive: 2717 drive_add(NULL, "%s", optarg); 2718 break; 2719 case QEMU_OPTION_mtdblock: 2720 drive_add(optarg, MTD_ALIAS); 2721 break; 2722 case QEMU_OPTION_sd: 2723 drive_add(optarg, SD_ALIAS); 2724 break; 2725 case QEMU_OPTION_pflash: 2726 drive_add(optarg, PFLASH_ALIAS); 2727 break; 2728 case QEMU_OPTION_snapshot: 2729 snapshot = 1; 2730 break; 2731 case QEMU_OPTION_hdachs: 2732 { 2733 const char *p; 2734 p = optarg; 2735 cyls = strtol(p, (char **)&p, 0); 2736 if (cyls < 1 || cyls > 16383) 2737 goto chs_fail; 2738 if (*p != ',') 2739 goto chs_fail; 2740 p++; 2741 heads = strtol(p, (char **)&p, 0); 2742 if (heads < 1 || heads > 16) 2743 goto chs_fail; 2744 if (*p != ',') 2745 goto chs_fail; 2746 p++; 2747 secs = strtol(p, (char **)&p, 0); 2748 if (secs < 1 || secs > 63) 2749 goto chs_fail; 2750 if (*p == ',') { 2751 p++; 2752 if (!strcmp(p, "none")) 2753 translation = BIOS_ATA_TRANSLATION_NONE; 2754 else if (!strcmp(p, "lba")) 2755 translation = BIOS_ATA_TRANSLATION_LBA; 2756 else if (!strcmp(p, "auto")) 2757 translation = BIOS_ATA_TRANSLATION_AUTO; 2758 else 2759 goto chs_fail; 2760 } else if (*p != '\0') { 2761 chs_fail: 2762 PANIC("qemu: invalid physical CHS format"); 2763 } 2764 if (hda_opts != NULL) { 2765 char num[16]; 2766 snprintf(num, sizeof(num), "%d", cyls); 2767 qemu_opt_set(hda_opts, "cyls", num); 2768 snprintf(num, sizeof(num), "%d", heads); 2769 qemu_opt_set(hda_opts, "heads", num); 2770 snprintf(num, sizeof(num), "%d", secs); 2771 qemu_opt_set(hda_opts, "secs", num); 2772 if (translation == BIOS_ATA_TRANSLATION_LBA) 2773 qemu_opt_set(hda_opts, "trans", "lba"); 2774 if (translation == BIOS_ATA_TRANSLATION_NONE) 2775 qemu_opt_set(hda_opts, "trans", "none"); 2776 } 2777 } 2778 break; 2779 case QEMU_OPTION_numa: 2780 if (nb_numa_nodes >= MAX_NODES) { 2781 PANIC("qemu: too many NUMA nodes"); 2782 } 2783 numa_add(optarg); 2784 break; 2785 case QEMU_OPTION_nographic: 2786 display_type = DT_NOGRAPHIC; 2787 break; 2788 #ifdef CONFIG_CURSES 2789 case QEMU_OPTION_curses: 2790 display_type = DT_CURSES; 2791 break; 2792 #endif 2793 case QEMU_OPTION_portrait: 2794 graphic_rotate = 1; 2795 break; 2796 case QEMU_OPTION_kernel: 2797 kernel_filename = optarg; 2798 break; 2799 case QEMU_OPTION_append: 2800 kernel_cmdline = optarg; 2801 break; 2802 case QEMU_OPTION_cdrom: 2803 drive_add(optarg, CDROM_ALIAS); 2804 break; 2805 case QEMU_OPTION_boot: 2806 boot_devices = optarg; 2807 /* We just do some generic consistency checks */ 2808 { 2809 /* Could easily be extended to 64 devices if needed */ 2810 const char *p; 2811 2812 boot_devices_bitmap = 0; 2813 for (p = boot_devices; *p != '\0'; p++) { 2814 /* Allowed boot devices are: 2815 * a b : floppy disk drives 2816 * c ... f : IDE disk drives 2817 * g ... m : machine implementation dependant drives 2818 * n ... p : network devices 2819 * It's up to each machine implementation to check 2820 * if the given boot devices match the actual hardware 2821 * implementation and firmware features. 2822 */ 2823 if (*p < 'a' || *p > 'q') { 2824 PANIC("Invalid boot device '%c'", *p); 2825 } 2826 if (boot_devices_bitmap & (1 << (*p - 'a'))) { 2827 PANIC( 2828 "Boot device '%c' was given twice",*p); 2829 } 2830 boot_devices_bitmap |= 1 << (*p - 'a'); 2831 } 2832 } 2833 break; 2834 case QEMU_OPTION_fda: 2835 case QEMU_OPTION_fdb: 2836 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda); 2837 break; 2838 #ifdef TARGET_I386 2839 case QEMU_OPTION_no_fd_bootchk: 2840 fd_bootchk = 0; 2841 break; 2842 #endif 2843 case QEMU_OPTION_net: 2844 if (nb_net_clients >= MAX_NET_CLIENTS) { 2845 PANIC("qemu: too many network clients"); 2846 } 2847 net_clients[nb_net_clients] = optarg; 2848 nb_net_clients++; 2849 break; 2850 #ifdef CONFIG_SLIRP 2851 case QEMU_OPTION_tftp: 2852 tftp_prefix = optarg; 2853 break; 2854 case QEMU_OPTION_bootp: 2855 bootp_filename = optarg; 2856 break; 2857 case QEMU_OPTION_redir: 2858 net_slirp_redir(NULL, optarg, NULL); 2859 break; 2860 #endif 2861 case QEMU_OPTION_bt: 2862 if (nb_bt_opts >= MAX_BT_CMDLINE) { 2863 PANIC("qemu: too many bluetooth options"); 2864 } 2865 bt_opts[nb_bt_opts++] = optarg; 2866 break; 2867 #ifdef HAS_AUDIO 2868 case QEMU_OPTION_audio_help: 2869 AUD_help (); 2870 QEMU_EXIT(0); 2871 break; 2872 case QEMU_OPTION_soundhw: 2873 select_soundhw (optarg); 2874 break; 2875 #endif 2876 case QEMU_OPTION_h: 2877 qemu_help(0); 2878 break; 2879 case QEMU_OPTION_version: 2880 version(); 2881 QEMU_EXIT(0); 2882 break; 2883 case QEMU_OPTION_m: { 2884 uint64_t value; 2885 char *ptr; 2886 2887 value = strtoul(optarg, &ptr, 10); 2888 switch (*ptr) { 2889 case 0: case 'M': case 'm': 2890 value <<= 20; 2891 break; 2892 case 'G': case 'g': 2893 value <<= 30; 2894 break; 2895 default: 2896 PANIC("qemu: invalid ram size: %s", optarg); 2897 } 2898 2899 /* On 32-bit hosts, QEMU is limited by virtual address space */ 2900 if (value > (2047 << 20) 2901 #ifndef CONFIG_KQEMU 2902 && HOST_LONG_BITS == 32 2903 #endif 2904 ) { 2905 PANIC("qemu: at most 2047 MB RAM can be simulated"); 2906 } 2907 if (value != (uint64_t)(ram_addr_t)value) { 2908 PANIC("qemu: ram size too large"); 2909 } 2910 ram_size = value; 2911 break; 2912 } 2913 case QEMU_OPTION_d: 2914 { 2915 int mask; 2916 const CPULogItem *item; 2917 2918 mask = cpu_str_to_log_mask(optarg); 2919 if (!mask) { 2920 printf("Log items (comma separated):\n"); 2921 for(item = cpu_log_items; item->mask != 0; item++) { 2922 printf("%-10s %s\n", item->name, item->help); 2923 } 2924 PANIC("Invalid parameter -d=%s", optarg); 2925 } 2926 cpu_set_log(mask); 2927 } 2928 break; 2929 case QEMU_OPTION_s: 2930 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT; 2931 break; 2932 case QEMU_OPTION_gdb: 2933 gdbstub_dev = optarg; 2934 break; 2935 case QEMU_OPTION_L: 2936 data_dir = optarg; 2937 break; 2938 case QEMU_OPTION_bios: 2939 bios_name = optarg; 2940 break; 2941 case QEMU_OPTION_singlestep: 2942 singlestep = 1; 2943 break; 2944 case QEMU_OPTION_S: 2945 autostart = 0; 2946 break; 2947 #ifndef _WIN32 2948 case QEMU_OPTION_k: 2949 keyboard_layout = optarg; 2950 break; 2951 #endif 2952 case QEMU_OPTION_localtime: 2953 rtc_utc = 0; 2954 break; 2955 case QEMU_OPTION_vga: 2956 select_vgahw (optarg); 2957 break; 2958 #if defined(TARGET_PPC) || defined(TARGET_SPARC) 2959 case QEMU_OPTION_g: 2960 { 2961 const char *p; 2962 int w, h, depth; 2963 p = optarg; 2964 w = strtol(p, (char **)&p, 10); 2965 if (w <= 0) { 2966 graphic_error: 2967 PANIC("qemu: invalid resolution or depth"); 2968 } 2969 if (*p != 'x') 2970 goto graphic_error; 2971 p++; 2972 h = strtol(p, (char **)&p, 10); 2973 if (h <= 0) 2974 goto graphic_error; 2975 if (*p == 'x') { 2976 p++; 2977 depth = strtol(p, (char **)&p, 10); 2978 if (depth != 8 && depth != 15 && depth != 16 && 2979 depth != 24 && depth != 32) 2980 goto graphic_error; 2981 } else if (*p == '\0') { 2982 depth = graphic_depth; 2983 } else { 2984 goto graphic_error; 2985 } 2986 2987 graphic_width = w; 2988 graphic_height = h; 2989 graphic_depth = depth; 2990 } 2991 break; 2992 #endif 2993 case QEMU_OPTION_echr: 2994 { 2995 char *r; 2996 term_escape_char = strtol(optarg, &r, 0); 2997 if (r == optarg) 2998 printf("Bad argument to echr\n"); 2999 break; 3000 } 3001 case QEMU_OPTION_monitor: 3002 monitor_device = optarg; 3003 break; 3004 case QEMU_OPTION_serial: 3005 if (serial_device_index >= MAX_SERIAL_PORTS) { 3006 PANIC("qemu: too many serial ports"); 3007 } 3008 serial_devices[serial_device_index] = optarg; 3009 serial_device_index++; 3010 break; 3011 case QEMU_OPTION_watchdog: 3012 i = select_watchdog(optarg); 3013 if (i > 0) { 3014 if (i == 1) { 3015 PANIC("Invalid watchdog parameter: %s", 3016 optarg); 3017 } else { 3018 QEMU_EXIT(0); 3019 } 3020 } 3021 break; 3022 case QEMU_OPTION_watchdog_action: 3023 if (select_watchdog_action(optarg) == -1) { 3024 PANIC("Unknown -watchdog-action parameter"); 3025 } 3026 break; 3027 case QEMU_OPTION_virtiocon: 3028 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) { 3029 PANIC("qemu: too many virtio consoles"); 3030 } 3031 virtio_consoles[virtio_console_index] = optarg; 3032 virtio_console_index++; 3033 break; 3034 case QEMU_OPTION_parallel: 3035 if (parallel_device_index >= MAX_PARALLEL_PORTS) { 3036 PANIC("qemu: too many parallel ports"); 3037 } 3038 parallel_devices[parallel_device_index] = optarg; 3039 parallel_device_index++; 3040 break; 3041 case QEMU_OPTION_loadvm: 3042 loadvm = optarg; 3043 break; 3044 case QEMU_OPTION_savevm_on_exit: 3045 savevm_on_exit = optarg; 3046 break; 3047 case QEMU_OPTION_full_screen: 3048 full_screen = 1; 3049 break; 3050 #ifdef CONFIG_SDL 3051 case QEMU_OPTION_no_frame: 3052 no_frame = 1; 3053 break; 3054 case QEMU_OPTION_alt_grab: 3055 alt_grab = 1; 3056 break; 3057 case QEMU_OPTION_no_quit: 3058 no_quit = 1; 3059 break; 3060 case QEMU_OPTION_sdl: 3061 display_type = DT_SDL; 3062 break; 3063 #endif 3064 case QEMU_OPTION_pidfile: 3065 pid_file = optarg; 3066 break; 3067 #ifdef TARGET_I386 3068 case QEMU_OPTION_win2k_hack: 3069 win2k_install_hack = 1; 3070 break; 3071 case QEMU_OPTION_rtc_td_hack: 3072 rtc_td_hack = 1; 3073 break; 3074 #ifndef CONFIG_ANDROID 3075 case QEMU_OPTION_acpitable: 3076 if(acpi_table_add(optarg) < 0) { 3077 PANIC("Wrong acpi table provided"); 3078 } 3079 break; 3080 #endif 3081 case QEMU_OPTION_smbios: 3082 do_smbios_option(optarg); 3083 break; 3084 #endif 3085 #ifdef CONFIG_KVM 3086 case QEMU_OPTION_enable_kvm: 3087 kvm_allowed = 1; 3088 break; 3089 case QEMU_OPTION_disable_kvm: 3090 kvm_allowed = 0; 3091 break; 3092 #endif /* CONFIG_KVM */ 3093 case QEMU_OPTION_usb: 3094 usb_enabled = 1; 3095 break; 3096 case QEMU_OPTION_usbdevice: 3097 usb_enabled = 1; 3098 if (usb_devices_index >= MAX_USB_CMDLINE) { 3099 PANIC("Too many USB devices"); 3100 } 3101 usb_devices[usb_devices_index] = optarg; 3102 usb_devices_index++; 3103 break; 3104 case QEMU_OPTION_smp: 3105 smp_cpus = atoi(optarg); 3106 if (smp_cpus < 1) { 3107 PANIC("Invalid number of CPUs"); 3108 } 3109 break; 3110 case QEMU_OPTION_vnc: 3111 display_type = DT_VNC; 3112 vnc_display = optarg; 3113 break; 3114 #ifdef TARGET_I386 3115 case QEMU_OPTION_no_acpi: 3116 acpi_enabled = 0; 3117 break; 3118 case QEMU_OPTION_no_hpet: 3119 no_hpet = 1; 3120 break; 3121 case QEMU_OPTION_no_virtio_balloon: 3122 no_virtio_balloon = 1; 3123 break; 3124 #endif 3125 case QEMU_OPTION_no_reboot: 3126 no_reboot = 1; 3127 break; 3128 case QEMU_OPTION_no_shutdown: 3129 no_shutdown = 1; 3130 break; 3131 case QEMU_OPTION_show_cursor: 3132 cursor_hide = 0; 3133 break; 3134 case QEMU_OPTION_uuid: 3135 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) { 3136 PANIC("Fail to parse UUID string. Wrong format."); 3137 } 3138 break; 3139 case QEMU_OPTION_option_rom: 3140 if (nb_option_roms >= MAX_OPTION_ROMS) { 3141 PANIC("Too many option ROMs"); 3142 } 3143 option_rom[nb_option_roms] = optarg; 3144 nb_option_roms++; 3145 break; 3146 #if defined(TARGET_ARM) || defined(TARGET_M68K) 3147 case QEMU_OPTION_semihosting: 3148 semihosting_enabled = 1; 3149 break; 3150 #endif 3151 case QEMU_OPTION_name: 3152 qemu_name = optarg; 3153 break; 3154 #if defined(TARGET_SPARC) || defined(TARGET_PPC) 3155 case QEMU_OPTION_prom_env: 3156 if (nb_prom_envs >= MAX_PROM_ENVS) { 3157 PANIC("Too many prom variables"); 3158 } 3159 prom_envs[nb_prom_envs] = optarg; 3160 nb_prom_envs++; 3161 break; 3162 #endif 3163 #ifdef TARGET_ARM 3164 case QEMU_OPTION_old_param: 3165 old_param = 1; 3166 break; 3167 #endif 3168 case QEMU_OPTION_clock: 3169 configure_alarms(optarg); 3170 break; 3171 case QEMU_OPTION_startdate: 3172 { 3173 struct tm tm; 3174 time_t rtc_start_date = 0; 3175 if (!strcmp(optarg, "now")) { 3176 rtc_date_offset = -1; 3177 } else { 3178 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d", 3179 &tm.tm_year, 3180 &tm.tm_mon, 3181 &tm.tm_mday, 3182 &tm.tm_hour, 3183 &tm.tm_min, 3184 &tm.tm_sec) == 6) { 3185 /* OK */ 3186 } else if (sscanf(optarg, "%d-%d-%d", 3187 &tm.tm_year, 3188 &tm.tm_mon, 3189 &tm.tm_mday) == 3) { 3190 tm.tm_hour = 0; 3191 tm.tm_min = 0; 3192 tm.tm_sec = 0; 3193 } else { 3194 goto date_fail; 3195 } 3196 tm.tm_year -= 1900; 3197 tm.tm_mon--; 3198 rtc_start_date = mktimegm(&tm); 3199 if (rtc_start_date == -1) { 3200 date_fail: 3201 PANIC("Invalid date format. Valid format are:\n" 3202 "'now' or '2006-06-17T16:01:21' or '2006-06-17'"); 3203 } 3204 rtc_date_offset = time(NULL) - rtc_start_date; 3205 } 3206 } 3207 break; 3208 3209 /* -------------------------------------------------------*/ 3210 /* User mode network stack restrictions */ 3211 case QEMU_OPTION_drop_udp: 3212 slirp_drop_udp(); 3213 break; 3214 case QEMU_OPTION_drop_tcp: 3215 slirp_drop_tcp(); 3216 break; 3217 case QEMU_OPTION_allow_tcp: 3218 slirp_allow(optarg, IPPROTO_TCP); 3219 break; 3220 case QEMU_OPTION_allow_udp: 3221 slirp_allow(optarg, IPPROTO_UDP); 3222 break; 3223 case QEMU_OPTION_drop_log: 3224 { 3225 FILE* drop_log_fd; 3226 drop_log_filename = optarg; 3227 drop_log_fd = fopen(optarg, "w+"); 3228 3229 if (!drop_log_fd) { 3230 fprintf(stderr, "Cannot open drop log: %s\n", optarg); 3231 exit(1); 3232 } 3233 3234 slirp_drop_log_fd(drop_log_fd); 3235 } 3236 break; 3237 3238 case QEMU_OPTION_dns_log: 3239 { 3240 FILE* dns_log_fd; 3241 dns_log_filename = optarg; 3242 dns_log_fd = fopen(optarg, "wb+"); 3243 3244 if (dns_log_fd == NULL) { 3245 fprintf(stderr, "Cannot open dns log: %s\n", optarg); 3246 exit(1); 3247 } 3248 3249 slirp_dns_log_fd(dns_log_fd); 3250 } 3251 break; 3252 3253 3254 case QEMU_OPTION_max_dns_conns: 3255 { 3256 int max_dns_conns = 0; 3257 if (parse_int(optarg, &max_dns_conns)) { 3258 fprintf(stderr, 3259 "qemu: syntax: -max-dns-conns max_connections\n"); 3260 exit(1); 3261 } 3262 if (max_dns_conns <= 0 || max_dns_conns == LONG_MAX) { 3263 fprintf(stderr, 3264 "Invalid arg for max dns connections: %s\n", 3265 optarg); 3266 exit(1); 3267 } 3268 slirp_set_max_dns_conns(max_dns_conns); 3269 } 3270 break; 3271 3272 case QEMU_OPTION_net_forward: 3273 net_slirp_forward(optarg); 3274 break; 3275 case QEMU_OPTION_net_forward_tcp2sink: 3276 { 3277 SockAddress saddr; 3278 3279 if (parse_host_port(&saddr, optarg)) { 3280 fprintf(stderr, 3281 "Invalid ip/port %s for " 3282 "-forward-dropped-tcp2sink. " 3283 "We expect 'sink_ip:sink_port'\n", 3284 optarg); 3285 exit(1); 3286 } 3287 slirp_forward_dropped_tcp2sink(saddr.u.inet.address, 3288 saddr.u.inet.port); 3289 } 3290 break; 3291 /* -------------------------------------------------------*/ 3292 3293 case QEMU_OPTION_tb_size: 3294 tb_size = strtol(optarg, NULL, 0); 3295 if (tb_size < 0) 3296 tb_size = 0; 3297 break; 3298 case QEMU_OPTION_icount: 3299 icount_option = optarg; 3300 break; 3301 case QEMU_OPTION_incoming: 3302 incoming = optarg; 3303 break; 3304 #ifdef CONFIG_XEN 3305 case QEMU_OPTION_xen_domid: 3306 xen_domid = atoi(optarg); 3307 break; 3308 case QEMU_OPTION_xen_create: 3309 xen_mode = XEN_CREATE; 3310 break; 3311 case QEMU_OPTION_xen_attach: 3312 xen_mode = XEN_ATTACH; 3313 break; 3314 #endif 3315 3316 3317 case QEMU_OPTION_mic: 3318 audio_input_source = (char*)optarg; 3319 break; 3320 #ifdef CONFIG_TRACE 3321 case QEMU_OPTION_trace: 3322 trace_filename = optarg; 3323 tracing = 1; 3324 break; 3325 #if 0 3326 case QEMU_OPTION_trace_miss: 3327 trace_cache_miss = 1; 3328 break; 3329 case QEMU_OPTION_trace_addr: 3330 trace_all_addr = 1; 3331 break; 3332 #endif 3333 case QEMU_OPTION_tracing: 3334 if (strcmp(optarg, "off") == 0) 3335 tracing = 0; 3336 else if (strcmp(optarg, "on") == 0 && trace_filename) 3337 tracing = 1; 3338 else { 3339 PANIC("Unexpected option to -tracing ('%s')", 3340 optarg); 3341 } 3342 break; 3343 #if 0 3344 case QEMU_OPTION_dcache_load_miss: 3345 dcache_load_miss_penalty = atoi(optarg); 3346 break; 3347 case QEMU_OPTION_dcache_store_miss: 3348 dcache_store_miss_penalty = atoi(optarg); 3349 break; 3350 #endif 3351 #endif 3352 #ifdef CONFIG_NAND 3353 case QEMU_OPTION_nand: 3354 nand_add_dev(optarg); 3355 break; 3356 #endif 3357 case QEMU_OPTION_android_ports: 3358 android_op_ports = (char*)optarg; 3359 break; 3360 3361 case QEMU_OPTION_android_port: 3362 android_op_port = (char*)optarg; 3363 break; 3364 3365 case QEMU_OPTION_android_report_console: 3366 android_op_report_console = (char*)optarg; 3367 break; 3368 3369 case QEMU_OPTION_http_proxy: 3370 op_http_proxy = (char*)optarg; 3371 break; 3372 3373 case QEMU_OPTION_charmap: 3374 op_charmap_file = (char*)optarg; 3375 break; 3376 3377 case QEMU_OPTION_android_hw: 3378 android_op_hwini = (char*)optarg; 3379 break; 3380 3381 case QEMU_OPTION_dns_server: 3382 android_op_dns_server = (char*)optarg; 3383 break; 3384 3385 case QEMU_OPTION_radio: 3386 android_op_radio = (char*)optarg; 3387 break; 3388 3389 case QEMU_OPTION_gps: 3390 android_op_gps = (char*)optarg; 3391 break; 3392 3393 case QEMU_OPTION_audio: 3394 android_op_audio = (char*)optarg; 3395 break; 3396 3397 case QEMU_OPTION_cpu_delay: 3398 android_op_cpu_delay = (char*)optarg; 3399 break; 3400 3401 case QEMU_OPTION_show_kernel: 3402 android_kmsg_init(ANDROID_KMSG_PRINT_MESSAGES); 3403 break; 3404 3405 #ifdef CONFIG_NAND_LIMITS 3406 case QEMU_OPTION_nand_limits: 3407 android_op_nand_limits = (char*)optarg; 3408 break; 3409 #endif // CONFIG_NAND_LIMITS 3410 3411 case QEMU_OPTION_netspeed: 3412 android_op_netspeed = (char*)optarg; 3413 break; 3414 3415 case QEMU_OPTION_netdelay: 3416 android_op_netdelay = (char*)optarg; 3417 break; 3418 3419 case QEMU_OPTION_netfast: 3420 android_op_netfast = 1; 3421 break; 3422 3423 case QEMU_OPTION_tcpdump: 3424 android_op_tcpdump = (char*)optarg; 3425 break; 3426 3427 case QEMU_OPTION_boot_property: 3428 boot_property_parse_option((char*)optarg); 3429 break; 3430 3431 case QEMU_OPTION_lcd_density: 3432 android_op_lcd_density = (char*)optarg; 3433 break; 3434 3435 case QEMU_OPTION_ui_port: 3436 android_op_ui_port = (char*)optarg; 3437 break; 3438 3439 case QEMU_OPTION_ui_settings: 3440 android_op_ui_settings = (char*)optarg; 3441 break; 3442 3443 case QEMU_OPTION_audio_test_out: 3444 android_audio_test_start_out(); 3445 break; 3446 3447 case QEMU_OPTION_android_avdname: 3448 android_op_avd_name = (char*)optarg; 3449 break; 3450 3451 case QEMU_OPTION_timezone: 3452 if (timezone_set((char*)optarg)) { 3453 fprintf(stderr, "emulator: it seems the timezone '%s' is not in zoneinfo format\n", 3454 (char*)optarg); 3455 } 3456 break; 3457 3458 #ifdef CONFIG_MEMCHECK 3459 case QEMU_OPTION_android_memcheck: 3460 android_op_memcheck = (char*)optarg; 3461 /* This will set ro.kernel.memcheck system property 3462 * to memcheck's tracing flags. */ 3463 stralloc_add_format(kernel_config, " memcheck=%s", android_op_memcheck); 3464 break; 3465 #endif // CONFIG_MEMCHECK 3466 3467 case QEMU_OPTION_snapshot_no_time_update: 3468 android_snapshot_update_time = 0; 3469 break; 3470 3471 case QEMU_OPTION_list_webcam: 3472 android_list_web_cameras(); 3473 exit(0); 3474 3475 default: 3476 os_parse_cmd_args(popt->index, optarg); 3477 } 3478 } 3479 } 3480 3481 /* Initialize character map. */ 3482 if (android_charmap_setup(op_charmap_file)) { 3483 if (op_charmap_file) { 3484 PANIC( 3485 "Unable to initialize character map from file %s.", 3486 op_charmap_file); 3487 } else { 3488 PANIC( 3489 "Unable to initialize default character map."); 3490 } 3491 } 3492 3493 /* If no data_dir is specified then try to find it relative to the 3494 executable path. */ 3495 if (!data_dir) { 3496 data_dir = find_datadir(argv[0]); 3497 } 3498 /* If all else fails use the install patch specified when building. */ 3499 if (!data_dir) { 3500 data_dir = CONFIG_QEMU_SHAREDIR; 3501 } 3502 3503 if (!android_op_hwini) { 3504 PANIC("Missing -android-hw <file> option!"); 3505 } 3506 hw_ini = iniFile_newFromFile(android_op_hwini); 3507 if (hw_ini == NULL) { 3508 PANIC("Could not find %s file.", android_op_hwini); 3509 } 3510 3511 androidHwConfig_init(android_hw, 0); 3512 androidHwConfig_read(android_hw, hw_ini); 3513 3514 iniFile_free(hw_ini); 3515 3516 { 3517 int width = android_hw->hw_lcd_width; 3518 int height = android_hw->hw_lcd_height; 3519 int depth = android_hw->hw_lcd_depth; 3520 3521 /* A bit of sanity checking */ 3522 if (width <= 0 || height <= 0 || 3523 (depth != 16 && depth != 32) || 3524 (((width|height) & 3) != 0) ) 3525 { 3526 PANIC("Invalid display configuration (%d,%d,%d)", 3527 width, height, depth); 3528 } 3529 android_display_width = width; 3530 android_display_height = height; 3531 android_display_bpp = depth; 3532 } 3533 3534 #ifdef CONFIG_NAND_LIMITS 3535 /* Init nand stuff. */ 3536 if (android_op_nand_limits) { 3537 parse_nand_limits(android_op_nand_limits); 3538 } 3539 #endif // CONFIG_NAND_LIMITS 3540 3541 /* Initialize AVD name from hardware configuration if needed */ 3542 if (!android_op_avd_name) { 3543 if (android_hw->avd_name && *android_hw->avd_name) { 3544 android_op_avd_name = android_hw->avd_name; 3545 VERBOSE_PRINT(init,"AVD Name: %s", android_op_avd_name); 3546 } 3547 } 3548 3549 /* Initialize system partition image */ 3550 { 3551 char tmp[PATH_MAX+32]; 3552 const char* sysImage = android_hw->disk_systemPartition_path; 3553 const char* initImage = android_hw->disk_systemPartition_initPath; 3554 uint64_t sysBytes = android_hw->disk_systemPartition_size; 3555 3556 if (sysBytes == 0) { 3557 PANIC("Invalid system partition size: %" PRUd64, sysBytes); 3558 } 3559 3560 snprintf(tmp,sizeof(tmp),"system,size=0x%" PRUx64, sysBytes); 3561 3562 if (sysImage && *sysImage) { 3563 if (filelock_create(sysImage) == NULL) { 3564 fprintf(stderr,"WARNING: System image already in use, changes will not persist!\n"); 3565 /* If there is no file= parameters, nand_add_dev will create 3566 * a temporary file to back the partition image. */ 3567 } else { 3568 pstrcat(tmp,sizeof(tmp),",file="); 3569 pstrcat(tmp,sizeof(tmp),sysImage); 3570 } 3571 } 3572 if (initImage && *initImage) { 3573 if (!path_exists(initImage)) { 3574 PANIC("Invalid initial system image path: %s", initImage); 3575 } 3576 pstrcat(tmp,sizeof(tmp),",initfile="); 3577 pstrcat(tmp,sizeof(tmp),initImage); 3578 } else { 3579 PANIC("Missing initial system image path!"); 3580 } 3581 nand_add_dev(tmp); 3582 } 3583 3584 /* Initialize data partition image */ 3585 { 3586 char tmp[PATH_MAX+32]; 3587 const char* dataImage = android_hw->disk_dataPartition_path; 3588 const char* initImage = android_hw->disk_dataPartition_initPath; 3589 uint64_t dataBytes = android_hw->disk_dataPartition_size; 3590 3591 if (dataBytes == 0) { 3592 PANIC("Invalid data partition size: %" PRUd64, dataBytes); 3593 } 3594 3595 snprintf(tmp,sizeof(tmp),"userdata,size=0x%" PRUx64, dataBytes); 3596 3597 if (dataImage && *dataImage) { 3598 if (filelock_create(dataImage) == NULL) { 3599 fprintf(stderr, "WARNING: Data partition already in use. Changes will not persist!\n"); 3600 /* Note: if there is no file= parameters, nand_add_dev() will 3601 * create a temporary file to back the partition image. */ 3602 } else { 3603 /* Create the file if needed */ 3604 if (!path_exists(dataImage)) { 3605 if (path_empty_file(dataImage) < 0) { 3606 PANIC("Could not create data image file %s: %s", dataImage, strerror(errno)); 3607 } 3608 } 3609 pstrcat(tmp, sizeof(tmp), ",file="); 3610 pstrcat(tmp, sizeof(tmp), dataImage); 3611 } 3612 } 3613 if (initImage && *initImage) { 3614 pstrcat(tmp, sizeof(tmp), ",initfile="); 3615 pstrcat(tmp, sizeof(tmp), initImage); 3616 } 3617 nand_add_dev(tmp); 3618 } 3619 3620 /* Init SD-Card stuff. For Android, it is always hda */ 3621 /* If the -hda option was used, ignore the Android-provided one */ 3622 if (hda_opts == NULL) { 3623 const char* sdPath = android_hw->hw_sdCard_path; 3624 if (sdPath && *sdPath) { 3625 if (!path_exists(sdPath)) { 3626 fprintf(stderr, "WARNING: SD Card image is missing: %s\n", sdPath); 3627 } else if (filelock_create(sdPath) == NULL) { 3628 fprintf(stderr, "WARNING: SD Card image already in use: %s\n", sdPath); 3629 } else { 3630 /* Successful locking */ 3631 hda_opts = drive_add(sdPath, HD_ALIAS, 0); 3632 /* Set this property of any operation involving the SD Card 3633 * will be x100 slower, due to the corresponding file being 3634 * mounted as O_DIRECT. Note that this is only 'unsafe' in 3635 * the context of an emulator crash. The data is already 3636 * synced properly when the emulator exits (either normally or through ^C). 3637 */ 3638 qemu_opt_set(hda_opts, "cache", "unsafe"); 3639 } 3640 } 3641 } 3642 3643 if (hdb_opts == NULL) { 3644 const char* spath = android_hw->disk_snapStorage_path; 3645 if (spath && *spath) { 3646 if (!path_exists(spath)) { 3647 PANIC("Snapshot storage file does not exist: %s", spath); 3648 } 3649 if (filelock_create(spath) == NULL) { 3650 PANIC("Snapshot storage already in use: %s", spath); 3651 } 3652 hdb_opts = drive_add(spath, HD_ALIAS, 1); 3653 /* See comment above to understand why this is needed. */ 3654 qemu_opt_set(hdb_opts, "cache", "unsafe"); 3655 } 3656 } 3657 3658 /* Set the VM's max heap size, passed as a boot property */ 3659 if (android_hw->vm_heapSize > 0) { 3660 char tmp[64]; 3661 snprintf(tmp, sizeof(tmp), "%dm", android_hw->vm_heapSize); 3662 boot_property_add("dalvik.vm.heapsize",tmp); 3663 } 3664 3665 /* Initialize net speed and delays stuff. */ 3666 if (android_parse_network_speed(android_op_netspeed) < 0 ) { 3667 PANIC("invalid -netspeed parameter '%s'", 3668 android_op_netspeed); 3669 } 3670 3671 if ( android_parse_network_latency(android_op_netdelay) < 0 ) { 3672 PANIC("invalid -netdelay parameter '%s'", 3673 android_op_netdelay); 3674 } 3675 3676 if (android_op_netfast) { 3677 qemu_net_download_speed = 0; 3678 qemu_net_upload_speed = 0; 3679 qemu_net_min_latency = 0; 3680 qemu_net_max_latency = 0; 3681 } 3682 3683 /* Initialize LCD density */ 3684 if (android_hw->hw_lcd_density) { 3685 long density = android_hw->hw_lcd_density; 3686 if (density <= 0) { 3687 PANIC("Invalid hw.lcd.density value: %ld", density); 3688 } 3689 hwLcd_setBootProperty(density); 3690 } 3691 3692 /* Initialize presence of hardware nav button */ 3693 boot_property_add("qemu.hw.mainkeys", android_hw->hw_mainKeys ? "1" : "0"); 3694 3695 /* Initialize TCP dump */ 3696 if (android_op_tcpdump) { 3697 if (qemu_tcpdump_start(android_op_tcpdump) < 0) { 3698 fprintf(stdout, "could not start packet capture: %s\n", strerror(errno)); 3699 } 3700 } 3701 3702 /* Initialize modem */ 3703 if (android_op_radio) { 3704 CharDriverState* cs = qemu_chr_open("radio", android_op_radio, NULL); 3705 if (cs == NULL) { 3706 PANIC("unsupported character device specification: %s\n" 3707 "used -help-char-devices for list of available formats", 3708 android_op_radio); 3709 } 3710 android_qemud_set_channel( ANDROID_QEMUD_GSM, cs); 3711 } else if (android_hw->hw_gsmModem != 0 ) { 3712 if ( android_qemud_get_channel( ANDROID_QEMUD_GSM, &android_modem_cs ) < 0 ) { 3713 PANIC("could not initialize qemud 'gsm' channel"); 3714 } 3715 } 3716 3717 /* Initialize GPS */ 3718 if (android_op_gps) { 3719 CharDriverState* cs = qemu_chr_open("gps", android_op_gps, NULL); 3720 if (cs == NULL) { 3721 PANIC("unsupported character device specification: %s\n" 3722 "used -help-char-devices for list of available formats", 3723 android_op_gps); 3724 } 3725 android_qemud_set_channel( ANDROID_QEMUD_GPS, cs); 3726 } else if (android_hw->hw_gps != 0) { 3727 if ( android_qemud_get_channel( "gps", &android_gps_cs ) < 0 ) { 3728 PANIC("could not initialize qemud 'gps' channel"); 3729 } 3730 } 3731 3732 /* Initialize audio. */ 3733 if (android_op_audio) { 3734 if ( !audio_check_backend_name( 0, android_op_audio ) ) { 3735 PANIC("'%s' is not a valid audio output backend. see -help-audio-out", 3736 android_op_audio); 3737 } 3738 setenv("QEMU_AUDIO_DRV", android_op_audio, 1); 3739 } 3740 3741 /* Initialize OpenGLES emulation */ 3742 //android_hw_opengles_init(); 3743 3744 /* Initialize fake camera */ 3745 if (android_hw->hw_fakeCamera) { 3746 boot_property_add("qemu.sf.fake_camera", android_hw->hw_fakeCamera); 3747 } else { 3748 boot_property_add("qemu.sf.fake_camera", "back"); 3749 } 3750 3751 /* Initialize camera emulation. */ 3752 android_camera_service_init(); 3753 3754 if (android_op_cpu_delay) { 3755 char* end; 3756 long delay = strtol(android_op_cpu_delay, &end, 0); 3757 if (end == NULL || *end || delay < 0 || delay > 1000 ) { 3758 PANIC("option -cpu-delay must be an integer between 0 and 1000" ); 3759 } 3760 if (delay > 0) 3761 delay = (1000-delay); 3762 3763 qemu_cpu_delay = (int) delay; 3764 } 3765 3766 if (android_op_dns_server) { 3767 char* x = strchr(android_op_dns_server, ','); 3768 dns_count = 0; 3769 if (x == NULL) 3770 { 3771 if ( add_dns_server( android_op_dns_server ) == 0 ) 3772 dns_count = 1; 3773 } 3774 else 3775 { 3776 x = android_op_dns_server; 3777 while (*x) { 3778 char* y = strchr(x, ','); 3779 3780 if (y != NULL) { 3781 *y = 0; 3782 y++; 3783 } else { 3784 y = x + strlen(x); 3785 } 3786 3787 if (y > x && add_dns_server( x ) == 0) { 3788 dns_count += 1; 3789 } 3790 x = y; 3791 } 3792 } 3793 if (dns_count == 0) 3794 fprintf( stdout, "### WARNING: will use system default DNS server\n" ); 3795 } 3796 3797 if (dns_count == 0) 3798 dns_count = slirp_get_system_dns_servers(); 3799 if (dns_count) { 3800 stralloc_add_format(kernel_config, " ndns=%d", dns_count); 3801 } 3802 3803 #ifdef CONFIG_MEMCHECK 3804 if (android_op_memcheck) { 3805 memcheck_init(android_op_memcheck); 3806 } 3807 #endif // CONFIG_MEMCHECK 3808 3809 /* Initialize cache partition, if any */ 3810 if (android_hw->disk_cachePartition != 0) { 3811 char tmp[PATH_MAX+32]; 3812 const char* partPath = android_hw->disk_cachePartition_path; 3813 uint64_t partSize = android_hw->disk_cachePartition_size; 3814 3815 snprintf(tmp,sizeof(tmp),"cache,size=0x%" PRUx64, partSize); 3816 3817 if (partPath && *partPath && strcmp(partPath, "<temp>") != 0) { 3818 if (filelock_create(partPath) == NULL) { 3819 fprintf(stderr, "WARNING: Cache partition already in use. Changes will not persist!\n"); 3820 /* Note: if there is no file= parameters, nand_add_dev() will 3821 * create a temporary file to back the partition image. */ 3822 } else { 3823 /* Create the file if needed */ 3824 if (!path_exists(partPath)) { 3825 if (path_empty_file(partPath) < 0) { 3826 PANIC("Could not create cache image file %s: %s", partPath, strerror(errno)); 3827 } 3828 } 3829 pstrcat(tmp, sizeof(tmp), ",file="); 3830 pstrcat(tmp, sizeof(tmp), partPath); 3831 } 3832 } 3833 nand_add_dev(tmp); 3834 } 3835 3836 /* qemu.gles will be read by the OpenGLES emulation libraries. 3837 * If set to 0, the software GLES renderer will be used as a fallback. 3838 * If the parameter is undefined, this means the system image runs 3839 * inside an emulator that doesn't support GPU emulation at all. 3840 */ 3841 { 3842 int gles_emul = 0; 3843 3844 if (android_hw->hw_gpu_enabled) { 3845 if (android_initOpenglesEmulation() == 0) { 3846 gles_emul = 1; 3847 android_startOpenglesRenderer(android_hw->hw_lcd_width, android_hw->hw_lcd_height); 3848 } else { 3849 dwarning("Could not initialize OpenglES emulation, using software renderer."); 3850 } 3851 } 3852 if (gles_emul) { 3853 stralloc_add_str(kernel_params, " qemu.gles=1"); 3854 } else { 3855 stralloc_add_str(kernel_params, " qemu.gles=0"); 3856 } 3857 } 3858 3859 /* We always force qemu=1 when running inside QEMU */ 3860 stralloc_add_str(kernel_params, " qemu=1"); 3861 3862 /* We always initialize the first serial port for the android-kmsg 3863 * character device (used to send kernel messages) */ 3864 serial_hds_add_at(0, "android-kmsg"); 3865 stralloc_add_str(kernel_params, " console=ttyS0"); 3866 3867 /* We always initialize the second serial port for the android-qemud 3868 * character device as well */ 3869 serial_hds_add_at(1, "android-qemud"); 3870 stralloc_add_str(kernel_params, " android.qemud=ttyS1"); 3871 3872 if (pid_file && qemu_create_pidfile(pid_file) != 0) { 3873 os_pidfile_error(); 3874 exit(1); 3875 } 3876 3877 #if defined(CONFIG_KVM) 3878 if (kvm_allowed < 0) { 3879 kvm_allowed = kvm_check_allowed(); 3880 } 3881 #endif 3882 3883 #if defined(CONFIG_KVM) && defined(CONFIG_KQEMU) 3884 if (kvm_allowed && kqemu_allowed) { 3885 PANIC( 3886 "You can not enable both KVM and kqemu at the same time"); 3887 } 3888 #endif 3889 3890 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */ 3891 if (smp_cpus > machine->max_cpus) { 3892 PANIC("Number of SMP cpus requested (%d), exceeds max cpus " 3893 "supported by machine `%s' (%d)", smp_cpus, machine->name, 3894 machine->max_cpus); 3895 } 3896 3897 if (display_type == DT_NOGRAPHIC) { 3898 if (serial_device_index == 0) 3899 serial_devices[0] = "stdio"; 3900 if (parallel_device_index == 0) 3901 parallel_devices[0] = "null"; 3902 if (strncmp(monitor_device, "vc", 2) == 0) 3903 monitor_device = "stdio"; 3904 } 3905 3906 #ifdef CONFIG_KQEMU 3907 if (smp_cpus > 1) 3908 kqemu_allowed = 0; 3909 #endif 3910 if (qemu_init_main_loop()) { 3911 PANIC("qemu_init_main_loop failed"); 3912 } 3913 3914 if (kernel_filename == NULL) { 3915 kernel_filename = android_hw->kernel_path; 3916 } 3917 if (initrd_filename == NULL) { 3918 initrd_filename = android_hw->disk_ramdisk_path; 3919 } 3920 3921 linux_boot = (kernel_filename != NULL); 3922 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF; 3923 3924 if (!linux_boot && *kernel_cmdline != '\0') { 3925 PANIC("-append only allowed with -kernel option"); 3926 } 3927 3928 if (!linux_boot && initrd_filename != NULL) { 3929 PANIC("-initrd only allowed with -kernel option"); 3930 } 3931 3932 /* boot to floppy or the default cd if no hard disk defined yet */ 3933 if (!boot_devices[0]) { 3934 boot_devices = "cad"; 3935 } 3936 os_set_line_buffering(); 3937 3938 if (init_timer_alarm() < 0) { 3939 PANIC("could not initialize alarm timer"); 3940 } 3941 configure_icount(icount_option); 3942 3943 /* init network clients */ 3944 if (nb_net_clients == 0) { 3945 /* if no clients, we use a default config */ 3946 net_clients[nb_net_clients++] = "nic"; 3947 #ifdef CONFIG_SLIRP 3948 net_clients[nb_net_clients++] = "user"; 3949 #endif 3950 } 3951 3952 for(i = 0;i < nb_net_clients; i++) { 3953 if (net_client_parse(net_clients[i]) < 0) { 3954 PANIC("Unable to parse net clients"); 3955 } 3956 } 3957 net_client_check(); 3958 3959 #ifdef TARGET_I386 3960 /* XXX: this should be moved in the PC machine instantiation code */ 3961 if (net_boot != 0) { 3962 int netroms = 0; 3963 for (i = 0; i < nb_nics && i < 4; i++) { 3964 const char *model = nd_table[i].model; 3965 char buf[1024]; 3966 char *filename; 3967 if (net_boot & (1 << i)) { 3968 if (model == NULL) 3969 model = "ne2k_pci"; 3970 snprintf(buf, sizeof(buf), "pxe-%s.bin", model); 3971 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, buf); 3972 if (filename && get_image_size(filename) > 0) { 3973 if (nb_option_roms >= MAX_OPTION_ROMS) { 3974 PANIC("Too many option ROMs"); 3975 } 3976 option_rom[nb_option_roms] = qemu_strdup(buf); 3977 nb_option_roms++; 3978 netroms++; 3979 } 3980 if (filename) { 3981 qemu_free(filename); 3982 } 3983 } 3984 } 3985 if (netroms == 0) { 3986 PANIC("No valid PXE rom found for network device"); 3987 } 3988 } 3989 #endif 3990 3991 /* init the bluetooth world */ 3992 for (i = 0; i < nb_bt_opts; i++) 3993 if (bt_parse(bt_opts[i])) { 3994 PANIC("Unable to parse bluetooth options"); 3995 } 3996 3997 /* init the memory */ 3998 if (ram_size == 0) { 3999 ram_size = android_hw->hw_ramSize * 1024LL * 1024; 4000 if (ram_size == 0) { 4001 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024; 4002 } 4003 } 4004 4005 #ifdef CONFIG_KQEMU 4006 /* FIXME: This is a nasty hack because kqemu can't cope with dynamic 4007 guest ram allocation. It needs to go away. */ 4008 if (kqemu_allowed) { 4009 kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024; 4010 kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size); 4011 if (!kqemu_phys_ram_base) { 4012 PANIC("Could not allocate physical memory"); 4013 } 4014 } 4015 #endif 4016 4017 #ifndef _WIN32 4018 init_qemu_clear_logs_sig(); 4019 #endif 4020 4021 /* init the dynamic translator */ 4022 cpu_exec_init_all(tb_size * 1024 * 1024); 4023 4024 bdrv_init(); 4025 4026 /* we always create the cdrom drive, even if no disk is there */ 4027 #if 0 4028 if (nb_drives_opt < MAX_DRIVES) 4029 drive_add(NULL, CDROM_ALIAS); 4030 4031 /* we always create at least one floppy */ 4032 4033 if (nb_drives_opt < MAX_DRIVES) 4034 drive_add(NULL, FD_ALIAS, 0); 4035 /* we always create one sd slot, even if no card is in it */ 4036 4037 if (1) { 4038 drive_add(NULL, SD_ALIAS); 4039 } 4040 #endif 4041 4042 /* open the virtual block devices */ 4043 if (snapshot) 4044 qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot, NULL, 0); 4045 if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func, &machine->use_scsi, 1) != 0) 4046 exit(1); 4047 4048 //register_savevm("timer", 0, 2, timer_save, timer_load, &timers_state); 4049 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL); 4050 4051 /* must be after terminal init, SDL library changes signal handlers */ 4052 os_setup_signal_handling(); 4053 4054 /* Maintain compatibility with multiple stdio monitors */ 4055 if (!strcmp(monitor_device,"stdio")) { 4056 for (i = 0; i < MAX_SERIAL_PORTS; i++) { 4057 const char *devname = serial_devices[i]; 4058 if (devname && !strcmp(devname,"mon:stdio")) { 4059 monitor_device = NULL; 4060 break; 4061 } else if (devname && !strcmp(devname,"stdio")) { 4062 monitor_device = NULL; 4063 serial_devices[i] = "mon:stdio"; 4064 break; 4065 } 4066 } 4067 } 4068 4069 if (nb_numa_nodes > 0) { 4070 int i; 4071 4072 if (nb_numa_nodes > smp_cpus) { 4073 nb_numa_nodes = smp_cpus; 4074 } 4075 4076 /* If no memory size if given for any node, assume the default case 4077 * and distribute the available memory equally across all nodes 4078 */ 4079 for (i = 0; i < nb_numa_nodes; i++) { 4080 if (node_mem[i] != 0) 4081 break; 4082 } 4083 if (i == nb_numa_nodes) { 4084 uint64_t usedmem = 0; 4085 4086 /* On Linux, the each node's border has to be 8MB aligned, 4087 * the final node gets the rest. 4088 */ 4089 for (i = 0; i < nb_numa_nodes - 1; i++) { 4090 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1); 4091 usedmem += node_mem[i]; 4092 } 4093 node_mem[i] = ram_size - usedmem; 4094 } 4095 4096 for (i = 0; i < nb_numa_nodes; i++) { 4097 if (node_cpumask[i] != 0) 4098 break; 4099 } 4100 /* assigning the VCPUs round-robin is easier to implement, guest OSes 4101 * must cope with this anyway, because there are BIOSes out there in 4102 * real machines which also use this scheme. 4103 */ 4104 if (i == nb_numa_nodes) { 4105 for (i = 0; i < smp_cpus; i++) { 4106 node_cpumask[i % nb_numa_nodes] |= 1 << i; 4107 } 4108 } 4109 } 4110 4111 if (kvm_enabled()) { 4112 int ret; 4113 4114 ret = kvm_init(smp_cpus); 4115 if (ret < 0) { 4116 PANIC("failed to initialize KVM"); 4117 } 4118 } 4119 4120 if (monitor_device) { 4121 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL); 4122 if (!monitor_hd) { 4123 PANIC("qemu: could not open monitor device '%s'", 4124 monitor_device); 4125 } 4126 } 4127 4128 for(i = 0; i < MAX_SERIAL_PORTS; i++) { 4129 serial_hds_add(serial_devices[i]); 4130 } 4131 4132 for(i = 0; i < MAX_PARALLEL_PORTS; i++) { 4133 const char *devname = parallel_devices[i]; 4134 if (devname && strcmp(devname, "none")) { 4135 char label[32]; 4136 snprintf(label, sizeof(label), "parallel%d", i); 4137 parallel_hds[i] = qemu_chr_open(label, devname, NULL); 4138 if (!parallel_hds[i]) { 4139 PANIC("qemu: could not open parallel device '%s'", 4140 devname); 4141 } 4142 } 4143 } 4144 4145 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) { 4146 const char *devname = virtio_consoles[i]; 4147 if (devname && strcmp(devname, "none")) { 4148 char label[32]; 4149 snprintf(label, sizeof(label), "virtcon%d", i); 4150 virtcon_hds[i] = qemu_chr_open(label, devname, NULL); 4151 if (!virtcon_hds[i]) { 4152 PANIC("qemu: could not open virtio console '%s'", 4153 devname); 4154 } 4155 } 4156 } 4157 4158 module_call_init(MODULE_INIT_DEVICE); 4159 4160 4161 #ifdef CONFIG_TRACE 4162 if (trace_filename) { 4163 trace_init(trace_filename); 4164 fprintf(stderr, "-- When done tracing, exit the emulator. --\n"); 4165 } 4166 #endif 4167 4168 /* Check the CPU Architecture value */ 4169 #if defined(TARGET_ARM) 4170 if (strcmp(android_hw->hw_cpu_arch,"arm") != 0) { 4171 fprintf(stderr, "-- Invalid CPU architecture: %s, expected 'arm'\n", 4172 android_hw->hw_cpu_arch); 4173 exit(1); 4174 } 4175 #elif defined(TARGET_I386) 4176 if (strcmp(android_hw->hw_cpu_arch,"x86") != 0) { 4177 fprintf(stderr, "-- Invalid CPU architecture: %s, expected 'x86'\n", 4178 android_hw->hw_cpu_arch); 4179 exit(1); 4180 } 4181 #endif 4182 4183 /* Grab CPU model if provided in hardware.ini */ 4184 if ( !cpu_model 4185 && android_hw->hw_cpu_model 4186 && android_hw->hw_cpu_model[0] != '\0') 4187 { 4188 cpu_model = android_hw->hw_cpu_model; 4189 } 4190 4191 /* Combine kernel command line passed from the UI with parameters 4192 * collected during initialization. 4193 * 4194 * The order is the following: 4195 * - parameters from the hw configuration (kernel.parameters) 4196 * - additionnal parameters from options (e.g. -memcheck) 4197 * - the -append parameters. 4198 */ 4199 { 4200 const char* kernel_parameters; 4201 4202 if (android_hw->kernel_parameters) { 4203 stralloc_add_c(kernel_params, ' '); 4204 stralloc_add_str(kernel_params, android_hw->kernel_parameters); 4205 } 4206 4207 /* If not empty, kernel_config always contains a leading space */ 4208 stralloc_append(kernel_params, kernel_config); 4209 4210 if (*kernel_cmdline) { 4211 stralloc_add_c(kernel_params, ' '); 4212 stralloc_add_str(kernel_params, kernel_cmdline); 4213 } 4214 4215 /* Remove any leading/trailing spaces */ 4216 stralloc_strip(kernel_params); 4217 4218 kernel_parameters = stralloc_cstr(kernel_params); 4219 VERBOSE_PRINT(init, "Kernel parameters: %s", kernel_parameters); 4220 4221 machine->init(ram_size, 4222 boot_devices, 4223 kernel_filename, 4224 kernel_parameters, 4225 initrd_filename, 4226 cpu_model); 4227 4228 stralloc_reset(kernel_params); 4229 stralloc_reset(kernel_config); 4230 } 4231 4232 4233 for (env = first_cpu; env != NULL; env = env->next_cpu) { 4234 for (i = 0; i < nb_numa_nodes; i++) { 4235 if (node_cpumask[i] & (1 << env->cpu_index)) { 4236 env->numa_node = i; 4237 } 4238 } 4239 } 4240 4241 current_machine = machine; 4242 4243 /* Set KVM's vcpu state to qemu's initial CPUState. */ 4244 if (kvm_enabled()) { 4245 int ret; 4246 4247 ret = kvm_sync_vcpus(); 4248 if (ret < 0) { 4249 PANIC("failed to initialize vcpus"); 4250 } 4251 } 4252 4253 /* init USB devices */ 4254 if (usb_enabled) { 4255 for(i = 0; i < usb_devices_index; i++) { 4256 if (usb_device_add(usb_devices[i], 0) < 0) { 4257 fprintf(stderr, "Warning: could not add USB device %s\n", 4258 usb_devices[i]); 4259 } 4260 } 4261 } 4262 4263 /* just use the first displaystate for the moment */ 4264 ds = get_displaystate(); 4265 4266 /* Initialize display from the command line parameters. */ 4267 android_display_reset(ds, 4268 android_display_width, 4269 android_display_height, 4270 android_display_bpp); 4271 4272 if (display_type == DT_DEFAULT) { 4273 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA) 4274 display_type = DT_SDL; 4275 #else 4276 display_type = DT_VNC; 4277 vnc_display = "localhost:0,to=99"; 4278 show_vnc_port = 1; 4279 #endif 4280 } 4281 4282 4283 switch (display_type) { 4284 case DT_NOGRAPHIC: 4285 break; 4286 #if defined(CONFIG_CURSES) 4287 case DT_CURSES: 4288 curses_display_init(ds, full_screen); 4289 break; 4290 #endif 4291 #if defined(CONFIG_SDL) && !defined(CONFIG_STANDALONE_CORE) 4292 case DT_SDL: 4293 sdl_display_init(ds, full_screen, no_frame); 4294 break; 4295 #elif defined(CONFIG_COCOA) 4296 case DT_SDL: 4297 cocoa_display_init(ds, full_screen); 4298 break; 4299 #elif defined(CONFIG_STANDALONE_CORE) 4300 case DT_SDL: 4301 coredisplay_init(ds); 4302 break; 4303 #endif 4304 case DT_VNC: 4305 vnc_display_init(ds); 4306 if (vnc_display_open(ds, vnc_display) < 0) { 4307 PANIC("Unable to initialize VNC display"); 4308 } 4309 4310 if (show_vnc_port) { 4311 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds)); 4312 } 4313 break; 4314 default: 4315 break; 4316 } 4317 dpy_resize(ds); 4318 4319 dcl = ds->listeners; 4320 while (dcl != NULL) { 4321 if (dcl->dpy_refresh != NULL) { 4322 ds->gui_timer = qemu_new_timer_ms(rt_clock, gui_update, ds); 4323 qemu_mod_timer(ds->gui_timer, qemu_get_clock_ms(rt_clock)); 4324 } 4325 dcl = dcl->next; 4326 } 4327 4328 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) { 4329 nographic_timer = qemu_new_timer_ms(rt_clock, nographic_update, NULL); 4330 qemu_mod_timer(nographic_timer, qemu_get_clock_ms(rt_clock)); 4331 } 4332 4333 text_consoles_set_display(ds); 4334 qemu_chr_initial_reset(); 4335 4336 if (monitor_device && monitor_hd) 4337 monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT); 4338 4339 for(i = 0; i < MAX_SERIAL_PORTS; i++) { 4340 const char *devname = serial_devices[i]; 4341 if (devname && strcmp(devname, "none")) { 4342 if (strstart(devname, "vc", 0)) 4343 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i); 4344 } 4345 } 4346 4347 for(i = 0; i < MAX_PARALLEL_PORTS; i++) { 4348 const char *devname = parallel_devices[i]; 4349 if (devname && strcmp(devname, "none")) { 4350 if (strstart(devname, "vc", 0)) 4351 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i); 4352 } 4353 } 4354 4355 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) { 4356 const char *devname = virtio_consoles[i]; 4357 if (virtcon_hds[i] && devname) { 4358 if (strstart(devname, "vc", 0)) 4359 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i); 4360 } 4361 } 4362 4363 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) { 4364 PANIC("qemu: could not open gdbserver on device '%s'", 4365 gdbstub_dev); 4366 } 4367 4368 /* call android-specific setup function */ 4369 android_emulation_setup(); 4370 4371 #if !defined(CONFIG_STANDALONE_CORE) 4372 // For the standalone emulator (UI+core in one executable) we need to 4373 // set the window title here. 4374 android_emulator_set_base_port(android_base_port); 4375 #endif 4376 4377 if (loadvm) 4378 do_loadvm(cur_mon, loadvm); 4379 4380 if (incoming) { 4381 autostart = 0; /* fixme how to deal with -daemonize */ 4382 qemu_start_incoming_migration(incoming); 4383 } 4384 4385 if (autostart) 4386 vm_start(); 4387 4388 os_setup_post(); 4389 4390 #ifdef CONFIG_ANDROID 4391 // This will notify the UI that the core is successfuly initialized 4392 android_core_init_completed(); 4393 #endif // CONFIG_ANDROID 4394 4395 main_loop(); 4396 quit_timers(); 4397 net_cleanup(); 4398 android_emulation_teardown(); 4399 return 0; 4400 } 4401 4402 void 4403 android_emulation_teardown(void) 4404 { 4405 android_charmap_done(); 4406 } 4407
