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