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