bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 1 | /* |
bellard | 80cabfa | 2004-03-14 12:20:30 +0000 | [diff] [blame] | 2 | * QEMU System Emulator |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 68d0f70 | 2008-01-06 17:21:48 +0000 | [diff] [blame] | 4 | * Copyright (c) 2003-2008 Fabrice Bellard |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 5 | * |
bellard | 1df912c | 2003-06-25 16:20:35 +0000 | [diff] [blame] | 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. |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 23 | */ |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 24 | #include <unistd.h> |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 25 | #include <fcntl.h> |
| 26 | #include <signal.h> |
| 27 | #include <time.h> |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 28 | #include <errno.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 29 | #include <sys/time.h> |
bellard | c88676f | 2006-08-06 13:36:11 +0000 | [diff] [blame] | 30 | #include <zlib.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 31 | |
Juan Quintela | 71e72a1 | 2009-07-27 16:12:56 +0200 | [diff] [blame] | 32 | /* Needed early for CONFIG_BSD etc. */ |
blueswir1 | d40cdb1 | 2009-03-07 16:52:02 +0000 | [diff] [blame] | 33 | #include "config-host.h" |
| 34 | |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 35 | #ifndef _WIN32 |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 36 | #include <libgen.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 37 | #include <sys/times.h> |
bellard | f1510b2 | 2003-06-25 00:07:40 +0000 | [diff] [blame] | 38 | #include <sys/wait.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 39 | #include <termios.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 40 | #include <sys/mman.h> |
bellard | f1510b2 | 2003-06-25 00:07:40 +0000 | [diff] [blame] | 41 | #include <sys/ioctl.h> |
blueswir1 | 24646c7 | 2008-11-07 16:55:48 +0000 | [diff] [blame] | 42 | #include <sys/resource.h> |
bellard | f1510b2 | 2003-06-25 00:07:40 +0000 | [diff] [blame] | 43 | #include <sys/socket.h> |
bellard | c94c8d6 | 2004-09-13 21:37:34 +0000 | [diff] [blame] | 44 | #include <netinet/in.h> |
blueswir1 | 24646c7 | 2008-11-07 16:55:48 +0000 | [diff] [blame] | 45 | #include <net/if.h> |
blueswir1 | 24646c7 | 2008-11-07 16:55:48 +0000 | [diff] [blame] | 46 | #include <arpa/inet.h> |
bellard | 9d728e8 | 2004-09-05 23:09:03 +0000 | [diff] [blame] | 47 | #include <dirent.h> |
bellard | 7c9d8e0 | 2005-11-15 22:16:05 +0000 | [diff] [blame] | 48 | #include <netdb.h> |
ths | cb4b976 | 2007-09-13 12:39:35 +0000 | [diff] [blame] | 49 | #include <sys/select.h> |
Prerna Saxena | ab6540d | 2010-08-09 11:48:32 +0100 | [diff] [blame] | 50 | |
Juan Quintela | 71e72a1 | 2009-07-27 16:12:56 +0200 | [diff] [blame] | 51 | #ifdef CONFIG_BSD |
bellard | 7d3505c | 2004-05-12 19:32:15 +0000 | [diff] [blame] | 52 | #include <sys/stat.h> |
Aurelien Jarno | a167ba5 | 2009-11-29 18:00:41 +0100 | [diff] [blame] | 53 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) |
Juergen Lock | 92c0e65 | 2010-03-25 22:07:12 +0100 | [diff] [blame] | 54 | #include <sys/sysctl.h> |
blueswir1 | 24646c7 | 2008-11-07 16:55:48 +0000 | [diff] [blame] | 55 | #else |
| 56 | #include <util.h> |
blueswir1 | 128ab2f | 2008-08-15 18:33:42 +0000 | [diff] [blame] | 57 | #endif |
Aurelien Jarno | bbe813a | 2009-11-30 15:42:59 +0100 | [diff] [blame] | 58 | #else |
blueswir1 | 223f0d7 | 2008-09-30 18:12:18 +0000 | [diff] [blame] | 59 | #ifdef __linux__ |
bellard | 7d3505c | 2004-05-12 19:32:15 +0000 | [diff] [blame] | 60 | #include <malloc.h> |
ths | bd494f4 | 2007-09-16 20:03:23 +0000 | [diff] [blame] | 61 | |
bellard | e57a8c0 | 2005-11-10 23:58:52 +0000 | [diff] [blame] | 62 | #include <linux/ppdev.h> |
ths | 5867c88 | 2007-02-17 23:44:43 +0000 | [diff] [blame] | 63 | #include <linux/parport.h> |
blueswir1 | 223f0d7 | 2008-09-30 18:12:18 +0000 | [diff] [blame] | 64 | #endif |
| 65 | #ifdef __sun__ |
ths | d5d10bc | 2007-02-17 22:54:49 +0000 | [diff] [blame] | 66 | #include <sys/stat.h> |
| 67 | #include <sys/ethernet.h> |
| 68 | #include <sys/sockio.h> |
ths | d5d10bc | 2007-02-17 22:54:49 +0000 | [diff] [blame] | 69 | #include <netinet/arp.h> |
ths | d5d10bc | 2007-02-17 22:54:49 +0000 | [diff] [blame] | 70 | #include <netinet/in_systm.h> |
| 71 | #include <netinet/ip.h> |
| 72 | #include <netinet/ip_icmp.h> // must come after ip.h |
| 73 | #include <netinet/udp.h> |
| 74 | #include <netinet/tcp.h> |
| 75 | #include <net/if.h> |
| 76 | #include <syslog.h> |
| 77 | #include <stropts.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 78 | #endif |
bellard | 7d3505c | 2004-05-12 19:32:15 +0000 | [diff] [blame] | 79 | #endif |
bellard | ec530c8 | 2006-04-25 22:36:06 +0000 | [diff] [blame] | 80 | #endif |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 81 | |
ths | 8a16d27 | 2008-07-19 09:56:24 +0000 | [diff] [blame] | 82 | #if defined(CONFIG_VDE) |
| 83 | #include <libvdeplug.h> |
| 84 | #endif |
| 85 | |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 86 | #ifdef _WIN32 |
aliguori | 49dc768 | 2009-03-08 16:26:59 +0000 | [diff] [blame] | 87 | #include <windows.h> |
bellard | 67b915a | 2004-03-31 23:37:16 +0000 | [diff] [blame] | 88 | #endif |
| 89 | |
bellard | 73332e5 | 2004-04-04 20:22:28 +0000 | [diff] [blame] | 90 | #ifdef CONFIG_SDL |
Stefan Weil | 59a36a2 | 2009-06-18 20:11:03 +0200 | [diff] [blame] | 91 | #if defined(__APPLE__) || defined(main) |
Stefan Weil | 6693665 | 2009-06-13 13:19:11 +0200 | [diff] [blame] | 92 | #include <SDL.h> |
malc | 880fec5 | 2009-02-15 20:18:41 +0000 | [diff] [blame] | 93 | int qemu_main(int argc, char **argv, char **envp); |
| 94 | int main(int argc, char **argv) |
| 95 | { |
Stefan Weil | 59a36a2 | 2009-06-18 20:11:03 +0200 | [diff] [blame] | 96 | return qemu_main(argc, argv, NULL); |
malc | 880fec5 | 2009-02-15 20:18:41 +0000 | [diff] [blame] | 97 | } |
| 98 | #undef main |
| 99 | #define main qemu_main |
bellard | 96bcd4f | 2004-07-10 16:26:15 +0000 | [diff] [blame] | 100 | #endif |
bellard | 73332e5 | 2004-04-04 20:22:28 +0000 | [diff] [blame] | 101 | #endif /* CONFIG_SDL */ |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 102 | |
bellard | 5b0753e | 2005-03-01 21:37:28 +0000 | [diff] [blame] | 103 | #ifdef CONFIG_COCOA |
| 104 | #undef main |
| 105 | #define main qemu_main |
| 106 | #endif /* CONFIG_COCOA */ |
| 107 | |
Anthony Liguori | 69e5bb6 | 2011-08-22 08:12:52 -0500 | [diff] [blame] | 108 | #include <glib.h> |
| 109 | |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 110 | #include "hw/hw.h" |
| 111 | #include "hw/boards.h" |
| 112 | #include "hw/usb.h" |
| 113 | #include "hw/pcmcia.h" |
| 114 | #include "hw/pc.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 115 | #include "hw/isa.h" |
| 116 | #include "hw/baum.h" |
| 117 | #include "hw/bt.h" |
Richard W.M. Jones | 9dd986c | 2009-04-25 13:56:19 +0100 | [diff] [blame] | 118 | #include "hw/watchdog.h" |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 119 | #include "hw/smbios.h" |
aliguori | e37630c | 2009-04-22 15:19:10 +0000 | [diff] [blame] | 120 | #include "hw/xen.h" |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 121 | #include "hw/qdev.h" |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 122 | #include "hw/loader.h" |
aurel32 | 5ef4efa | 2009-03-10 21:43:35 +0000 | [diff] [blame] | 123 | #include "bt-host.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 124 | #include "net.h" |
Mark McLoughlin | 68ac40d | 2009-11-25 18:48:54 +0000 | [diff] [blame] | 125 | #include "net/slirp.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 126 | #include "monitor.h" |
| 127 | #include "console.h" |
| 128 | #include "sysemu.h" |
| 129 | #include "gdbstub.h" |
| 130 | #include "qemu-timer.h" |
| 131 | #include "qemu-char.h" |
| 132 | #include "cache-utils.h" |
| 133 | #include "block.h" |
Markus Armbruster | 666daa6 | 2010-06-02 18:48:27 +0200 | [diff] [blame] | 134 | #include "blockdev.h" |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 135 | #include "block-migration.h" |
blueswir1 | a718ace | 2009-03-28 08:24:44 +0000 | [diff] [blame] | 136 | #include "dma.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 137 | #include "audio/audio.h" |
| 138 | #include "migration.h" |
| 139 | #include "kvm.h" |
Luiz Capitulino | f795e74 | 2011-10-21 16:05:43 -0200 | [diff] [blame] | 140 | #include "qjson.h" |
Kevin Wolf | d3f2436 | 2009-05-18 16:42:09 +0200 | [diff] [blame] | 141 | #include "qemu-option.h" |
Gerd Hoffmann | 7282a03 | 2009-07-31 12:25:35 +0200 | [diff] [blame] | 142 | #include "qemu-config.h" |
Jes Sorensen | 59a5264 | 2010-06-10 11:42:25 +0200 | [diff] [blame] | 143 | #include "qemu-options.h" |
Luiz Capitulino | 1fa9a5e | 2011-09-12 17:54:20 -0300 | [diff] [blame] | 144 | #include "qmp-commands.h" |
Paolo Bonzini | 44a9b35 | 2011-09-12 16:44:30 +0200 | [diff] [blame] | 145 | #include "main-loop.h" |
Venkateswararao Jujjuri (JV) | 758e8e3 | 2010-06-14 13:34:41 -0700 | [diff] [blame] | 146 | #ifdef CONFIG_VIRTFS |
Gautham R Shenoy | 74db920 | 2010-04-29 17:44:43 +0530 | [diff] [blame] | 147 | #include "fsdev/qemu-fsdev.h" |
| 148 | #endif |
Anthony Liguori | c7f0f3b | 2012-03-28 15:42:02 +0200 | [diff] [blame] | 149 | #include "qtest.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 150 | |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 151 | #include "disas.h" |
bellard | fc01f7e | 2003-06-30 10:03:06 +0000 | [diff] [blame] | 152 | |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 153 | #include "qemu_socket.h" |
| 154 | |
Jan Kiszka | d918f23 | 2009-06-24 14:42:30 +0200 | [diff] [blame] | 155 | #include "slirp/libslirp.h" |
blueswir1 | 511d2b1 | 2009-03-07 15:32:56 +0000 | [diff] [blame] | 156 | |
Stefan Hajnoczi | 94b0b5f | 2010-11-16 12:20:25 +0000 | [diff] [blame] | 157 | #include "trace.h" |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 158 | #include "trace/control.h" |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 159 | #include "qemu-queue.h" |
Blue Swirl | 296af7c | 2010-03-29 19:23:50 +0000 | [diff] [blame] | 160 | #include "cpus.h" |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 161 | #include "arch_init.h" |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 162 | |
Gerd Hoffmann | 29b0040 | 2010-03-11 11:13:27 -0300 | [diff] [blame] | 163 | #include "ui/qemu-spice.h" |
| 164 | |
blueswir1 | 9dc63a1 | 2008-10-04 07:25:46 +0000 | [diff] [blame] | 165 | //#define DEBUG_NET |
| 166 | //#define DEBUG_SLIRP |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 167 | |
bellard | 1bfe856 | 2004-07-08 21:17:50 +0000 | [diff] [blame] | 168 | #define DEFAULT_RAM_SIZE 128 |
bellard | 313aa56 | 2003-08-10 21:52:11 +0000 | [diff] [blame] | 169 | |
Amit Shah | 98b1925 | 2010-01-20 00:36:52 +0530 | [diff] [blame] | 170 | #define MAX_VIRTIO_CONSOLES 1 |
| 171 | |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 172 | static const char *data_dir; |
j_mayer | 1192dad | 2007-10-05 13:08:35 +0000 | [diff] [blame] | 173 | const char *bios_name = NULL; |
malc | cb5a7aa | 2008-09-28 00:42:12 +0000 | [diff] [blame] | 174 | enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB; |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 175 | DisplayType display_type = DT_DEFAULT; |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 176 | int display_remote = 0; |
bellard | 3d11d0e | 2004-12-12 16:56:30 +0000 | [diff] [blame] | 177 | const char* keyboard_layout = NULL; |
Anthony Liguori | c227f09 | 2009-10-01 16:12:16 -0500 | [diff] [blame] | 178 | ram_addr_t ram_size; |
Marcelo Tosatti | c902760 | 2010-03-01 20:25:08 -0300 | [diff] [blame] | 179 | const char *mem_path = NULL; |
| 180 | #ifdef MAP_POPULATE |
| 181 | int mem_prealloc = 0; /* force preallocation of physical target memory */ |
| 182 | #endif |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 183 | int nb_nics; |
bellard | 7c9d8e0 | 2005-11-15 22:16:05 +0000 | [diff] [blame] | 184 | NICInfo nd_table[MAX_NICS]; |
Paolo Bonzini | d399f67 | 2009-07-27 23:17:51 +0200 | [diff] [blame] | 185 | int autostart; |
balrog | f650305 | 2008-02-17 11:42:19 +0000 | [diff] [blame] | 186 | static int rtc_utc = 1; |
| 187 | static int rtc_date_offset = -1; /* -1 means no change */ |
Jan Kiszka | 6875204 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 188 | QEMUClock *rtc_clock; |
Gerd Hoffmann | 6446529 | 2009-12-08 13:11:45 +0100 | [diff] [blame] | 189 | int vga_interface_type = VGA_NONE; |
blueswir1 | dbed7e4 | 2008-10-01 19:38:09 +0000 | [diff] [blame] | 190 | static int full_screen = 0; |
blueswir1 | 634a21f | 2008-11-16 11:34:07 +0000 | [diff] [blame] | 191 | #ifdef CONFIG_SDL |
blueswir1 | dbed7e4 | 2008-10-01 19:38:09 +0000 | [diff] [blame] | 192 | static int no_frame = 0; |
blueswir1 | 634a21f | 2008-11-16 11:34:07 +0000 | [diff] [blame] | 193 | #endif |
ths | 667acca | 2006-12-11 02:08:05 +0000 | [diff] [blame] | 194 | int no_quit = 0; |
bellard | 8d11df9 | 2004-08-24 21:13:40 +0000 | [diff] [blame] | 195 | CharDriverState *serial_hds[MAX_SERIAL_PORTS]; |
bellard | 6508fe5 | 2005-01-15 12:02:56 +0000 | [diff] [blame] | 196 | CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; |
aliguori | 9ede2fd | 2009-01-15 20:05:25 +0000 | [diff] [blame] | 197 | CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES]; |
bellard | a09db21 | 2005-04-30 16:10:35 +0000 | [diff] [blame] | 198 | int win2k_install_hack = 0; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 199 | int usb_enabled = 0; |
aurel32 | 1b530a6 | 2009-04-05 20:08:59 +0000 | [diff] [blame] | 200 | int singlestep = 0; |
bellard | 6a00d60 | 2005-11-21 23:25:50 +0000 | [diff] [blame] | 201 | int smp_cpus = 1; |
Jes Sorensen | 6be68d7 | 2009-07-23 17:03:42 +0200 | [diff] [blame] | 202 | int max_cpus = 0; |
Andre Przywara | dc6b1c0 | 2009-08-19 15:42:40 +0200 | [diff] [blame] | 203 | int smp_cores = 1; |
| 204 | int smp_threads = 1; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 205 | #ifdef CONFIG_VNC |
ths | 73fc974 | 2006-12-22 02:09:07 +0000 | [diff] [blame] | 206 | const char *vnc_display; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 207 | #endif |
bellard | 6515b20 | 2006-05-03 22:02:44 +0000 | [diff] [blame] | 208 | int acpi_enabled = 1; |
aliguori | 16b29ae | 2008-12-17 23:28:44 +0000 | [diff] [blame] | 209 | int no_hpet = 0; |
bellard | 52ca8d6 | 2006-06-14 16:03:05 +0000 | [diff] [blame] | 210 | int fd_bootchk = 1; |
bellard | d1beab8 | 2006-10-02 19:44:22 +0000 | [diff] [blame] | 211 | int no_reboot = 0; |
aurel32 | b2f7616 | 2008-04-11 21:35:52 +0000 | [diff] [blame] | 212 | int no_shutdown = 0; |
balrog | 9467cd4 | 2007-05-01 01:34:14 +0000 | [diff] [blame] | 213 | int cursor_hide = 1; |
balrog | a171fe3 | 2007-04-30 01:48:07 +0000 | [diff] [blame] | 214 | int graphic_rotate = 0; |
Markus Armbruster | 09aaa16 | 2009-08-21 10:31:34 +0200 | [diff] [blame] | 215 | const char *watchdog; |
Gleb Natapov | 2e55e84 | 2010-12-08 13:35:07 +0200 | [diff] [blame] | 216 | QEMUOptionRom option_rom[MAX_OPTION_ROMS]; |
ths | 9ae0255 | 2007-01-05 17:39:04 +0000 | [diff] [blame] | 217 | int nb_option_roms; |
pbrook | 8e71621 | 2007-01-20 17:12:09 +0000 | [diff] [blame] | 218 | int semihosting_enabled = 0; |
balrog | 2b8f2d4 | 2007-07-27 22:08:46 +0000 | [diff] [blame] | 219 | int old_param = 0; |
ths | c35734b | 2007-03-19 15:17:08 +0000 | [diff] [blame] | 220 | const char *qemu_name; |
ths | 3780e19 | 2007-06-21 21:08:02 +0000 | [diff] [blame] | 221 | int alt_grab = 0; |
Dustin Kirkland | 0ca9f8a | 2009-09-17 15:48:04 -0500 | [diff] [blame] | 222 | int ctrl_grab = 0; |
blueswir1 | 6650860 | 2007-05-01 14:16:52 +0000 | [diff] [blame] | 223 | unsigned int nb_prom_envs = 0; |
| 224 | const char *prom_envs[MAX_PROM_ENVS]; |
Jan Kiszka | 9538749 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 225 | int boot_menu; |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 226 | uint8_t *boot_splash_filedata; |
| 227 | int boot_splash_filedata_size; |
| 228 | uint8_t qemu_extra_params_fw[2]; |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 229 | |
Gleb Natapov | 1ca4d09 | 2010-12-08 13:35:05 +0200 | [diff] [blame] | 230 | typedef struct FWBootEntry FWBootEntry; |
| 231 | |
| 232 | struct FWBootEntry { |
| 233 | QTAILQ_ENTRY(FWBootEntry) link; |
| 234 | int32_t bootindex; |
| 235 | DeviceState *dev; |
| 236 | char *suffix; |
| 237 | }; |
| 238 | |
| 239 | QTAILQ_HEAD(, FWBootEntry) fw_boot_order = QTAILQ_HEAD_INITIALIZER(fw_boot_order); |
| 240 | |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 241 | int nb_numa_nodes; |
| 242 | uint64_t node_mem[MAX_NODES]; |
| 243 | uint64_t node_cpumask[MAX_NODES]; |
| 244 | |
blueswir1 | 8fcb1b9 | 2008-09-18 18:29:08 +0000 | [diff] [blame] | 245 | uint8_t qemu_uuid[16]; |
| 246 | |
Jan Kiszka | 76e30d0 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 247 | static QEMUBootSetHandler *boot_set_handler; |
| 248 | static void *boot_set_opaque; |
| 249 | |
Gerd Hoffmann | fd42dee | 2010-06-04 14:08:07 +0200 | [diff] [blame] | 250 | static NotifierList exit_notifiers = |
| 251 | NOTIFIER_LIST_INITIALIZER(exit_notifiers); |
| 252 | |
Gleb Natapov | 4cab946 | 2010-12-08 13:35:08 +0200 | [diff] [blame] | 253 | static NotifierList machine_init_done_notifiers = |
| 254 | NOTIFIER_LIST_INITIALIZER(machine_init_done_notifiers); |
| 255 | |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 256 | static int tcg_allowed = 1; |
Blue Swirl | d745bef | 2010-03-29 19:23:49 +0000 | [diff] [blame] | 257 | int kvm_allowed = 0; |
Anthony PERARD | 3285cf4 | 2010-08-19 12:27:56 +0100 | [diff] [blame] | 258 | int xen_allowed = 0; |
Blue Swirl | d745bef | 2010-03-29 19:23:49 +0000 | [diff] [blame] | 259 | uint32_t xen_domid; |
| 260 | enum xen_mode xen_mode = XEN_EMULATE; |
Jan Kiszka | d5ab971 | 2011-08-02 16:10:21 +0200 | [diff] [blame] | 261 | static int tcg_tb_size; |
Blue Swirl | d745bef | 2010-03-29 19:23:49 +0000 | [diff] [blame] | 262 | |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 263 | static int default_serial = 1; |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 264 | static int default_parallel = 1; |
Gerd Hoffmann | 986c5f7 | 2009-12-08 13:11:54 +0100 | [diff] [blame] | 265 | static int default_virtcon = 1; |
Gerd Hoffmann | abdeed0 | 2009-12-08 13:11:43 +0100 | [diff] [blame] | 266 | static int default_monitor = 1; |
Gerd Hoffmann | ac33f8f | 2009-12-16 14:25:39 +0100 | [diff] [blame] | 267 | static int default_floppy = 1; |
| 268 | static int default_cdrom = 1; |
| 269 | static int default_sdcard = 1; |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 270 | static int default_vga = 1; |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 271 | |
| 272 | static struct { |
| 273 | const char *driver; |
| 274 | int *flag; |
| 275 | } default_list[] = { |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 276 | { .driver = "isa-serial", .flag = &default_serial }, |
| 277 | { .driver = "isa-parallel", .flag = &default_parallel }, |
Gerd Hoffmann | d8bcbab | 2009-12-16 14:25:40 +0100 | [diff] [blame] | 278 | { .driver = "isa-fdc", .flag = &default_floppy }, |
Markus Armbruster | af6bf13 | 2011-05-18 18:31:02 +0200 | [diff] [blame] | 279 | { .driver = "ide-cd", .flag = &default_cdrom }, |
| 280 | { .driver = "ide-hd", .flag = &default_cdrom }, |
Gerd Hoffmann | d8bcbab | 2009-12-16 14:25:40 +0100 | [diff] [blame] | 281 | { .driver = "ide-drive", .flag = &default_cdrom }, |
Markus Armbruster | af6bf13 | 2011-05-18 18:31:02 +0200 | [diff] [blame] | 282 | { .driver = "scsi-cd", .flag = &default_cdrom }, |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 283 | { .driver = "virtio-serial-pci", .flag = &default_virtcon }, |
| 284 | { .driver = "virtio-serial-s390", .flag = &default_virtcon }, |
| 285 | { .driver = "virtio-serial", .flag = &default_virtcon }, |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 286 | { .driver = "VGA", .flag = &default_vga }, |
| 287 | { .driver = "isa-vga", .flag = &default_vga }, |
| 288 | { .driver = "cirrus-vga", .flag = &default_vga }, |
| 289 | { .driver = "isa-cirrus-vga", .flag = &default_vga }, |
| 290 | { .driver = "vmware-svga", .flag = &default_vga }, |
| 291 | { .driver = "qxl-vga", .flag = &default_vga }, |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 292 | }; |
| 293 | |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 294 | static void res_free(void) |
| 295 | { |
| 296 | if (boot_splash_filedata != NULL) { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 297 | g_free(boot_splash_filedata); |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 298 | boot_splash_filedata = NULL; |
| 299 | } |
| 300 | } |
| 301 | |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 302 | static int default_driver_check(QemuOpts *opts, void *opaque) |
| 303 | { |
| 304 | const char *driver = qemu_opt_get(opts, "driver"); |
| 305 | int i; |
| 306 | |
| 307 | if (!driver) |
| 308 | return 0; |
| 309 | for (i = 0; i < ARRAY_SIZE(default_list); i++) { |
| 310 | if (strcmp(default_list[i].driver, driver) != 0) |
| 311 | continue; |
| 312 | *(default_list[i].flag) = 0; |
| 313 | } |
| 314 | return 0; |
| 315 | } |
| 316 | |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 317 | /***********************************************************/ |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 318 | /* QEMU state */ |
| 319 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 320 | static RunState current_run_state = RUN_STATE_PRELAUNCH; |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 321 | |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 322 | typedef struct { |
| 323 | RunState from; |
| 324 | RunState to; |
| 325 | } RunStateTransition; |
| 326 | |
| 327 | static const RunStateTransition runstate_transitions_def[] = { |
| 328 | /* from -> to */ |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 329 | { RUN_STATE_DEBUG, RUN_STATE_RUNNING }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 330 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 331 | { RUN_STATE_INMIGRATE, RUN_STATE_RUNNING }, |
| 332 | { RUN_STATE_INMIGRATE, RUN_STATE_PRELAUNCH }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 333 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 334 | { RUN_STATE_INTERNAL_ERROR, RUN_STATE_PAUSED }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 335 | { RUN_STATE_INTERNAL_ERROR, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 336 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 337 | { RUN_STATE_IO_ERROR, RUN_STATE_RUNNING }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 338 | { RUN_STATE_IO_ERROR, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 339 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 340 | { RUN_STATE_PAUSED, RUN_STATE_RUNNING }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 341 | { RUN_STATE_PAUSED, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 342 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 343 | { RUN_STATE_POSTMIGRATE, RUN_STATE_RUNNING }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 344 | { RUN_STATE_POSTMIGRATE, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 345 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 346 | { RUN_STATE_PRELAUNCH, RUN_STATE_RUNNING }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 347 | { RUN_STATE_PRELAUNCH, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 348 | { RUN_STATE_PRELAUNCH, RUN_STATE_INMIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 349 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 350 | { RUN_STATE_FINISH_MIGRATE, RUN_STATE_RUNNING }, |
| 351 | { RUN_STATE_FINISH_MIGRATE, RUN_STATE_POSTMIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 352 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 353 | { RUN_STATE_RESTORE_VM, RUN_STATE_RUNNING }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 354 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 355 | { RUN_STATE_RUNNING, RUN_STATE_DEBUG }, |
| 356 | { RUN_STATE_RUNNING, RUN_STATE_INTERNAL_ERROR }, |
| 357 | { RUN_STATE_RUNNING, RUN_STATE_IO_ERROR }, |
| 358 | { RUN_STATE_RUNNING, RUN_STATE_PAUSED }, |
| 359 | { RUN_STATE_RUNNING, RUN_STATE_FINISH_MIGRATE }, |
| 360 | { RUN_STATE_RUNNING, RUN_STATE_RESTORE_VM }, |
| 361 | { RUN_STATE_RUNNING, RUN_STATE_SAVE_VM }, |
| 362 | { RUN_STATE_RUNNING, RUN_STATE_SHUTDOWN }, |
| 363 | { RUN_STATE_RUNNING, RUN_STATE_WATCHDOG }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 364 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 365 | { RUN_STATE_SAVE_VM, RUN_STATE_RUNNING }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 366 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 367 | { RUN_STATE_SHUTDOWN, RUN_STATE_PAUSED }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 368 | { RUN_STATE_SHUTDOWN, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 369 | |
Luiz Capitulino | ad02b96 | 2012-04-27 13:33:36 -0300 | [diff] [blame] | 370 | { RUN_STATE_DEBUG, RUN_STATE_SUSPENDED }, |
| 371 | { RUN_STATE_RUNNING, RUN_STATE_SUSPENDED }, |
| 372 | { RUN_STATE_SUSPENDED, RUN_STATE_RUNNING }, |
| 373 | { RUN_STATE_SUSPENDED, RUN_STATE_FINISH_MIGRATE }, |
| 374 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 375 | { RUN_STATE_WATCHDOG, RUN_STATE_RUNNING }, |
Luiz Capitulino | 8a9236f | 2011-10-14 11:18:09 -0300 | [diff] [blame] | 376 | { RUN_STATE_WATCHDOG, RUN_STATE_FINISH_MIGRATE }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 377 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 378 | { RUN_STATE_MAX, RUN_STATE_MAX }, |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 379 | }; |
| 380 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 381 | static bool runstate_valid_transitions[RUN_STATE_MAX][RUN_STATE_MAX]; |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 382 | |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 383 | bool runstate_check(RunState state) |
| 384 | { |
| 385 | return current_run_state == state; |
| 386 | } |
| 387 | |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 388 | void runstate_init(void) |
| 389 | { |
| 390 | const RunStateTransition *p; |
| 391 | |
| 392 | memset(&runstate_valid_transitions, 0, sizeof(runstate_valid_transitions)); |
| 393 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 394 | for (p = &runstate_transitions_def[0]; p->from != RUN_STATE_MAX; p++) { |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 395 | runstate_valid_transitions[p->from][p->to] = true; |
| 396 | } |
| 397 | } |
| 398 | |
| 399 | /* This function will abort() on invalid state transitions */ |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 400 | void runstate_set(RunState new_state) |
| 401 | { |
Luiz Capitulino | 207c5cd | 2011-10-13 10:59:07 -0300 | [diff] [blame] | 402 | assert(new_state < RUN_STATE_MAX); |
| 403 | |
| 404 | if (!runstate_valid_transitions[current_run_state][new_state]) { |
| 405 | fprintf(stderr, "ERROR: invalid runstate transition: '%s' -> '%s'\n", |
| 406 | RunState_lookup[current_run_state], |
| 407 | RunState_lookup[new_state]); |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 408 | abort(); |
| 409 | } |
| 410 | |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 411 | current_run_state = new_state; |
| 412 | } |
| 413 | |
Luiz Capitulino | 1354869 | 2011-07-29 15:36:43 -0300 | [diff] [blame] | 414 | int runstate_is_running(void) |
| 415 | { |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 416 | return runstate_check(RUN_STATE_RUNNING); |
Luiz Capitulino | 1354869 | 2011-07-29 15:36:43 -0300 | [diff] [blame] | 417 | } |
| 418 | |
Luiz Capitulino | 1fa9a5e | 2011-09-12 17:54:20 -0300 | [diff] [blame] | 419 | StatusInfo *qmp_query_status(Error **errp) |
| 420 | { |
| 421 | StatusInfo *info = g_malloc0(sizeof(*info)); |
| 422 | |
| 423 | info->running = runstate_is_running(); |
| 424 | info->singlestep = singlestep; |
| 425 | info->status = current_run_state; |
| 426 | |
| 427 | return info; |
| 428 | } |
| 429 | |
Luiz Capitulino | f5bbfba | 2011-07-29 15:04:45 -0300 | [diff] [blame] | 430 | /***********************************************************/ |
Paolo Bonzini | 8f0056b | 2010-01-13 14:05:34 +0100 | [diff] [blame] | 431 | /* real time host monotonic timer */ |
bellard | 09b26c5 | 2006-04-12 21:09:08 +0000 | [diff] [blame] | 432 | |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 433 | /***********************************************************/ |
balrog | f650305 | 2008-02-17 11:42:19 +0000 | [diff] [blame] | 434 | /* host time/date access */ |
| 435 | void qemu_get_timedate(struct tm *tm, int offset) |
| 436 | { |
| 437 | time_t ti; |
| 438 | struct tm *ret; |
| 439 | |
| 440 | time(&ti); |
| 441 | ti += offset; |
| 442 | if (rtc_date_offset == -1) { |
| 443 | if (rtc_utc) |
| 444 | ret = gmtime(&ti); |
| 445 | else |
| 446 | ret = localtime(&ti); |
| 447 | } else { |
| 448 | ti -= rtc_date_offset; |
| 449 | ret = gmtime(&ti); |
| 450 | } |
| 451 | |
| 452 | memcpy(tm, ret, sizeof(struct tm)); |
| 453 | } |
| 454 | |
| 455 | int qemu_timedate_diff(struct tm *tm) |
| 456 | { |
| 457 | time_t seconds; |
| 458 | |
| 459 | if (rtc_date_offset == -1) |
| 460 | if (rtc_utc) |
| 461 | seconds = mktimegm(tm); |
Gleb Natapov | f54c556 | 2011-11-06 18:00:22 +0200 | [diff] [blame] | 462 | else { |
| 463 | struct tm tmp = *tm; |
| 464 | tmp.tm_isdst = -1; /* use timezone to figure it out */ |
| 465 | seconds = mktime(&tmp); |
| 466 | } |
balrog | f650305 | 2008-02-17 11:42:19 +0000 | [diff] [blame] | 467 | else |
| 468 | seconds = mktimegm(tm) + rtc_date_offset; |
| 469 | |
| 470 | return seconds - time(NULL); |
| 471 | } |
| 472 | |
Luiz Capitulino | 80cd347 | 2010-02-25 12:11:44 -0300 | [diff] [blame] | 473 | void rtc_change_mon_event(struct tm *tm) |
| 474 | { |
| 475 | QObject *data; |
| 476 | |
| 477 | data = qobject_from_jsonf("{ 'offset': %d }", qemu_timedate_diff(tm)); |
| 478 | monitor_protocol_event(QEVENT_RTC_CHANGE, data); |
| 479 | qobject_decref(data); |
| 480 | } |
| 481 | |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 482 | static void configure_rtc_date_offset(const char *startdate, int legacy) |
| 483 | { |
| 484 | time_t rtc_start_date; |
| 485 | struct tm tm; |
| 486 | |
| 487 | if (!strcmp(startdate, "now") && legacy) { |
| 488 | rtc_date_offset = -1; |
| 489 | } else { |
| 490 | if (sscanf(startdate, "%d-%d-%dT%d:%d:%d", |
| 491 | &tm.tm_year, |
| 492 | &tm.tm_mon, |
| 493 | &tm.tm_mday, |
| 494 | &tm.tm_hour, |
| 495 | &tm.tm_min, |
| 496 | &tm.tm_sec) == 6) { |
| 497 | /* OK */ |
| 498 | } else if (sscanf(startdate, "%d-%d-%d", |
| 499 | &tm.tm_year, |
| 500 | &tm.tm_mon, |
| 501 | &tm.tm_mday) == 3) { |
| 502 | tm.tm_hour = 0; |
| 503 | tm.tm_min = 0; |
| 504 | tm.tm_sec = 0; |
| 505 | } else { |
| 506 | goto date_fail; |
| 507 | } |
| 508 | tm.tm_year -= 1900; |
| 509 | tm.tm_mon--; |
| 510 | rtc_start_date = mktimegm(&tm); |
| 511 | if (rtc_start_date == -1) { |
| 512 | date_fail: |
| 513 | fprintf(stderr, "Invalid date format. Valid formats are:\n" |
| 514 | "'2006-06-17T16:01:21' or '2006-06-17'\n"); |
| 515 | exit(1); |
| 516 | } |
| 517 | rtc_date_offset = time(NULL) - rtc_start_date; |
| 518 | } |
| 519 | } |
| 520 | |
| 521 | static void configure_rtc(QemuOpts *opts) |
| 522 | { |
| 523 | const char *value; |
| 524 | |
| 525 | value = qemu_opt_get(opts, "base"); |
| 526 | if (value) { |
| 527 | if (!strcmp(value, "utc")) { |
| 528 | rtc_utc = 1; |
| 529 | } else if (!strcmp(value, "localtime")) { |
| 530 | rtc_utc = 0; |
| 531 | } else { |
| 532 | configure_rtc_date_offset(value, 0); |
| 533 | } |
| 534 | } |
Jan Kiszka | 6875204 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 535 | value = qemu_opt_get(opts, "clock"); |
| 536 | if (value) { |
| 537 | if (!strcmp(value, "host")) { |
| 538 | rtc_clock = host_clock; |
Paolo Bonzini | 7880814 | 2012-03-30 10:31:21 +0000 | [diff] [blame] | 539 | } else if (!strcmp(value, "rt")) { |
| 540 | rtc_clock = rt_clock; |
Jan Kiszka | 6875204 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 541 | } else if (!strcmp(value, "vm")) { |
| 542 | rtc_clock = vm_clock; |
| 543 | } else { |
| 544 | fprintf(stderr, "qemu: invalid option value '%s'\n", value); |
| 545 | exit(1); |
| 546 | } |
| 547 | } |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 548 | value = qemu_opt_get(opts, "driftfix"); |
| 549 | if (value) { |
Blue Swirl | 7e4c033 | 2010-03-27 21:33:46 +0000 | [diff] [blame] | 550 | if (!strcmp(value, "slew")) { |
Jan Kiszka | 433acf0 | 2012-01-23 20:15:12 +0100 | [diff] [blame] | 551 | static GlobalProperty slew_lost_ticks[] = { |
| 552 | { |
| 553 | .driver = "mc146818rtc", |
| 554 | .property = "lost_tick_policy", |
| 555 | .value = "slew", |
| 556 | }, |
| 557 | { /* end of list */ } |
| 558 | }; |
| 559 | |
| 560 | qdev_prop_register_global_list(slew_lost_ticks); |
Blue Swirl | 7e4c033 | 2010-03-27 21:33:46 +0000 | [diff] [blame] | 561 | } else if (!strcmp(value, "none")) { |
Jan Kiszka | 433acf0 | 2012-01-23 20:15:12 +0100 | [diff] [blame] | 562 | /* discard is default */ |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 563 | } else { |
| 564 | fprintf(stderr, "qemu: invalid option value '%s'\n", value); |
| 565 | exit(1); |
| 566 | } |
| 567 | } |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 568 | } |
| 569 | |
balrog | 1ae26a1 | 2008-09-28 23:19:47 +0000 | [diff] [blame] | 570 | /***********************************************************/ |
| 571 | /* Bluetooth support */ |
| 572 | static int nb_hcis; |
| 573 | static int cur_hci; |
| 574 | static struct HCIInfo *hci_table[MAX_NICS]; |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 575 | |
balrog | 1ae26a1 | 2008-09-28 23:19:47 +0000 | [diff] [blame] | 576 | static struct bt_vlan_s { |
| 577 | struct bt_scatternet_s net; |
| 578 | int id; |
| 579 | struct bt_vlan_s *next; |
| 580 | } *first_bt_vlan; |
| 581 | |
| 582 | /* find or alloc a new bluetooth "VLAN" */ |
blueswir1 | 674bb26 | 2008-09-30 18:18:27 +0000 | [diff] [blame] | 583 | static struct bt_scatternet_s *qemu_find_bt_vlan(int id) |
balrog | 1ae26a1 | 2008-09-28 23:19:47 +0000 | [diff] [blame] | 584 | { |
| 585 | struct bt_vlan_s **pvlan, *vlan; |
| 586 | for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) { |
| 587 | if (vlan->id == id) |
| 588 | return &vlan->net; |
| 589 | } |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 590 | vlan = g_malloc0(sizeof(struct bt_vlan_s)); |
balrog | 1ae26a1 | 2008-09-28 23:19:47 +0000 | [diff] [blame] | 591 | vlan->id = id; |
| 592 | pvlan = &first_bt_vlan; |
| 593 | while (*pvlan != NULL) |
| 594 | pvlan = &(*pvlan)->next; |
| 595 | *pvlan = vlan; |
| 596 | return &vlan->net; |
| 597 | } |
| 598 | |
| 599 | static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len) |
| 600 | { |
| 601 | } |
| 602 | |
| 603 | static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr) |
| 604 | { |
| 605 | return -ENOTSUP; |
| 606 | } |
| 607 | |
| 608 | static struct HCIInfo null_hci = { |
| 609 | .cmd_send = null_hci_send, |
| 610 | .sco_send = null_hci_send, |
| 611 | .acl_send = null_hci_send, |
| 612 | .bdaddr_set = null_hci_addr_set, |
| 613 | }; |
| 614 | |
| 615 | struct HCIInfo *qemu_next_hci(void) |
| 616 | { |
| 617 | if (cur_hci == nb_hcis) |
| 618 | return &null_hci; |
| 619 | |
| 620 | return hci_table[cur_hci++]; |
| 621 | } |
| 622 | |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 623 | static struct HCIInfo *hci_init(const char *str) |
| 624 | { |
| 625 | char *endp; |
| 626 | struct bt_scatternet_s *vlan = 0; |
| 627 | |
| 628 | if (!strcmp(str, "null")) |
| 629 | /* null */ |
| 630 | return &null_hci; |
| 631 | else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':')) |
| 632 | /* host[:hciN] */ |
| 633 | return bt_host_hci(str[4] ? str + 5 : "hci0"); |
| 634 | else if (!strncmp(str, "hci", 3)) { |
| 635 | /* hci[,vlan=n] */ |
| 636 | if (str[3]) { |
| 637 | if (!strncmp(str + 3, ",vlan=", 6)) { |
| 638 | vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0)); |
| 639 | if (*endp) |
| 640 | vlan = 0; |
| 641 | } |
| 642 | } else |
| 643 | vlan = qemu_find_bt_vlan(0); |
| 644 | if (vlan) |
| 645 | return bt_new_hci(vlan); |
| 646 | } |
| 647 | |
| 648 | fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str); |
| 649 | |
| 650 | return 0; |
| 651 | } |
| 652 | |
| 653 | static int bt_hci_parse(const char *str) |
| 654 | { |
| 655 | struct HCIInfo *hci; |
Anthony Liguori | c227f09 | 2009-10-01 16:12:16 -0500 | [diff] [blame] | 656 | bdaddr_t bdaddr; |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 657 | |
| 658 | if (nb_hcis >= MAX_NICS) { |
| 659 | fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS); |
| 660 | return -1; |
| 661 | } |
| 662 | |
| 663 | hci = hci_init(str); |
| 664 | if (!hci) |
| 665 | return -1; |
| 666 | |
| 667 | bdaddr.b[0] = 0x52; |
| 668 | bdaddr.b[1] = 0x54; |
| 669 | bdaddr.b[2] = 0x00; |
| 670 | bdaddr.b[3] = 0x12; |
| 671 | bdaddr.b[4] = 0x34; |
| 672 | bdaddr.b[5] = 0x56 + nb_hcis; |
| 673 | hci->bdaddr_set(hci, bdaddr.b); |
| 674 | |
| 675 | hci_table[nb_hcis++] = hci; |
| 676 | |
| 677 | return 0; |
| 678 | } |
| 679 | |
| 680 | static void bt_vhci_add(int vlan_id) |
| 681 | { |
| 682 | struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id); |
| 683 | |
| 684 | if (!vlan->slave) |
| 685 | fprintf(stderr, "qemu: warning: adding a VHCI to " |
| 686 | "an empty scatternet %i\n", vlan_id); |
| 687 | |
| 688 | bt_vhci_init(bt_new_hci(vlan)); |
| 689 | } |
| 690 | |
| 691 | static struct bt_device_s *bt_device_add(const char *opt) |
| 692 | { |
| 693 | struct bt_scatternet_s *vlan; |
| 694 | int vlan_id = 0; |
| 695 | char *endp = strstr(opt, ",vlan="); |
| 696 | int len = (endp ? endp - opt : strlen(opt)) + 1; |
| 697 | char devname[10]; |
| 698 | |
| 699 | pstrcpy(devname, MIN(sizeof(devname), len), opt); |
| 700 | |
| 701 | if (endp) { |
| 702 | vlan_id = strtol(endp + 6, &endp, 0); |
| 703 | if (*endp) { |
| 704 | fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n"); |
| 705 | return 0; |
| 706 | } |
| 707 | } |
| 708 | |
| 709 | vlan = qemu_find_bt_vlan(vlan_id); |
| 710 | |
| 711 | if (!vlan->slave) |
| 712 | fprintf(stderr, "qemu: warning: adding a slave device to " |
| 713 | "an empty scatternet %i\n", vlan_id); |
| 714 | |
| 715 | if (!strcmp(devname, "keyboard")) |
| 716 | return bt_keyboard_init(vlan); |
| 717 | |
| 718 | fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname); |
| 719 | return 0; |
| 720 | } |
| 721 | |
| 722 | static int bt_parse(const char *opt) |
| 723 | { |
| 724 | const char *endp, *p; |
| 725 | int vlan; |
| 726 | |
| 727 | if (strstart(opt, "hci", &endp)) { |
| 728 | if (!*endp || *endp == ',') { |
| 729 | if (*endp) |
| 730 | if (!strstart(endp, ",vlan=", 0)) |
| 731 | opt = endp + 1; |
| 732 | |
| 733 | return bt_hci_parse(opt); |
| 734 | } |
| 735 | } else if (strstart(opt, "vhci", &endp)) { |
| 736 | if (!*endp || *endp == ',') { |
| 737 | if (*endp) { |
| 738 | if (strstart(endp, ",vlan=", &p)) { |
| 739 | vlan = strtol(p, (char **) &endp, 0); |
| 740 | if (*endp) { |
| 741 | fprintf(stderr, "qemu: bad scatternet '%s'\n", p); |
| 742 | return 1; |
| 743 | } |
| 744 | } else { |
| 745 | fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1); |
| 746 | return 1; |
| 747 | } |
| 748 | } else |
| 749 | vlan = 0; |
| 750 | |
| 751 | bt_vhci_add(vlan); |
| 752 | return 0; |
| 753 | } |
| 754 | } else if (strstart(opt, "device:", &endp)) |
| 755 | return !bt_device_add(endp); |
| 756 | |
| 757 | fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt); |
| 758 | return 1; |
| 759 | } |
| 760 | |
balrog | 1ae26a1 | 2008-09-28 23:19:47 +0000 | [diff] [blame] | 761 | /***********************************************************/ |
| 762 | /* QEMU Block devices */ |
| 763 | |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 764 | #define HD_OPTS "media=disk" |
| 765 | #define CDROM_OPTS "media=cdrom" |
| 766 | #define FD_OPTS "" |
| 767 | #define PFLASH_OPTS "" |
| 768 | #define MTD_OPTS "" |
| 769 | #define SD_OPTS "" |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 770 | |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 771 | static int drive_init_func(QemuOpts *opts, void *opaque) |
| 772 | { |
Markus Armbruster | a803cb8 | 2010-06-02 13:31:55 +0200 | [diff] [blame] | 773 | int *use_scsi = opaque; |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 774 | |
Markus Armbruster | 319ae52 | 2011-01-28 11:21:46 +0100 | [diff] [blame] | 775 | return drive_init(opts, *use_scsi) == NULL; |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 776 | } |
| 777 | |
| 778 | static int drive_enable_snapshot(QemuOpts *opts, void *opaque) |
| 779 | { |
| 780 | if (NULL == qemu_opt_get(opts, "snapshot")) { |
| 781 | qemu_opt_set(opts, "snapshot", "on"); |
| 782 | } |
| 783 | return 0; |
| 784 | } |
| 785 | |
Markus Armbruster | 4e5d9b5 | 2011-01-28 11:21:45 +0100 | [diff] [blame] | 786 | static void default_drive(int enable, int snapshot, int use_scsi, |
| 787 | BlockInterfaceType type, int index, |
| 788 | const char *optstr) |
| 789 | { |
| 790 | QemuOpts *opts; |
| 791 | |
| 792 | if (type == IF_DEFAULT) { |
| 793 | type = use_scsi ? IF_SCSI : IF_IDE; |
| 794 | } |
| 795 | |
| 796 | if (!enable || drive_get_by_index(type, index)) { |
| 797 | return; |
| 798 | } |
| 799 | |
| 800 | opts = drive_add(type, index, NULL, optstr); |
| 801 | if (snapshot) { |
| 802 | drive_enable_snapshot(opts, NULL); |
| 803 | } |
Markus Armbruster | 319ae52 | 2011-01-28 11:21:46 +0100 | [diff] [blame] | 804 | if (!drive_init(opts, use_scsi)) { |
Markus Armbruster | 4e5d9b5 | 2011-01-28 11:21:45 +0100 | [diff] [blame] | 805 | exit(1); |
| 806 | } |
| 807 | } |
| 808 | |
Jan Kiszka | 76e30d0 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 809 | void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque) |
| 810 | { |
| 811 | boot_set_handler = func; |
| 812 | boot_set_opaque = opaque; |
| 813 | } |
| 814 | |
| 815 | int qemu_boot_set(const char *boot_devices) |
| 816 | { |
| 817 | if (!boot_set_handler) { |
| 818 | return -EINVAL; |
| 819 | } |
| 820 | return boot_set_handler(boot_set_opaque, boot_devices); |
| 821 | } |
| 822 | |
Eduardo Habkost | 4e9e9d6 | 2010-04-06 19:22:08 -0300 | [diff] [blame] | 823 | static void validate_bootdevices(char *devices) |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 824 | { |
| 825 | /* We just do some generic consistency checks */ |
| 826 | const char *p; |
| 827 | int bitmap = 0; |
| 828 | |
| 829 | for (p = devices; *p != '\0'; p++) { |
| 830 | /* Allowed boot devices are: |
| 831 | * a-b: floppy disk drives |
| 832 | * c-f: IDE disk drives |
Dong Xu Wang | 07f3507 | 2011-11-22 18:06:26 +0800 | [diff] [blame] | 833 | * g-m: machine implementation dependent drives |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 834 | * n-p: network devices |
| 835 | * It's up to each machine implementation to check if the given boot |
| 836 | * devices match the actual hardware implementation and firmware |
| 837 | * features. |
| 838 | */ |
| 839 | if (*p < 'a' || *p > 'p') { |
| 840 | fprintf(stderr, "Invalid boot device '%c'\n", *p); |
| 841 | exit(1); |
| 842 | } |
| 843 | if (bitmap & (1 << (*p - 'a'))) { |
| 844 | fprintf(stderr, "Boot device '%c' was given twice\n", *p); |
| 845 | exit(1); |
| 846 | } |
| 847 | bitmap |= 1 << (*p - 'a'); |
| 848 | } |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 849 | } |
| 850 | |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 851 | static void restore_boot_devices(void *opaque) |
| 852 | { |
| 853 | char *standard_boot_devices = opaque; |
Alex Williamson | 37905d6 | 2010-04-30 15:21:11 -0600 | [diff] [blame] | 854 | static int first = 1; |
| 855 | |
| 856 | /* Restore boot order and remove ourselves after the first boot */ |
| 857 | if (first) { |
| 858 | first = 0; |
| 859 | return; |
| 860 | } |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 861 | |
| 862 | qemu_boot_set(standard_boot_devices); |
| 863 | |
| 864 | qemu_unregister_reset(restore_boot_devices, standard_boot_devices); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 865 | g_free(standard_boot_devices); |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 866 | } |
| 867 | |
Gleb Natapov | 1ca4d09 | 2010-12-08 13:35:05 +0200 | [diff] [blame] | 868 | void add_boot_device_path(int32_t bootindex, DeviceState *dev, |
| 869 | const char *suffix) |
| 870 | { |
| 871 | FWBootEntry *node, *i; |
| 872 | |
| 873 | if (bootindex < 0) { |
| 874 | return; |
| 875 | } |
| 876 | |
| 877 | assert(dev != NULL || suffix != NULL); |
| 878 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 879 | node = g_malloc0(sizeof(FWBootEntry)); |
Gleb Natapov | 1ca4d09 | 2010-12-08 13:35:05 +0200 | [diff] [blame] | 880 | node->bootindex = bootindex; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 881 | node->suffix = suffix ? g_strdup(suffix) : NULL; |
Gleb Natapov | 1ca4d09 | 2010-12-08 13:35:05 +0200 | [diff] [blame] | 882 | node->dev = dev; |
| 883 | |
| 884 | QTAILQ_FOREACH(i, &fw_boot_order, link) { |
| 885 | if (i->bootindex == bootindex) { |
| 886 | fprintf(stderr, "Two devices with same boot index %d\n", bootindex); |
| 887 | exit(1); |
| 888 | } else if (i->bootindex < bootindex) { |
| 889 | continue; |
| 890 | } |
| 891 | QTAILQ_INSERT_BEFORE(i, node, link); |
| 892 | return; |
| 893 | } |
| 894 | QTAILQ_INSERT_TAIL(&fw_boot_order, node, link); |
| 895 | } |
| 896 | |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 897 | /* |
| 898 | * This function returns null terminated string that consist of new line |
Brad Hards | 71785ab | 2011-04-23 21:50:06 +1000 | [diff] [blame] | 899 | * separated device paths. |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 900 | * |
| 901 | * memory pointed by "size" is assigned total length of the array in bytes |
| 902 | * |
| 903 | */ |
| 904 | char *get_boot_devices_list(uint32_t *size) |
| 905 | { |
| 906 | FWBootEntry *i; |
| 907 | uint32_t total = 0; |
| 908 | char *list = NULL; |
| 909 | |
| 910 | QTAILQ_FOREACH(i, &fw_boot_order, link) { |
| 911 | char *devpath = NULL, *bootpath; |
| 912 | int len; |
| 913 | |
| 914 | if (i->dev) { |
| 915 | devpath = qdev_get_fw_dev_path(i->dev); |
| 916 | assert(devpath); |
| 917 | } |
| 918 | |
| 919 | if (i->suffix && devpath) { |
Blue Swirl | 4fd37a9 | 2010-12-19 14:05:43 +0000 | [diff] [blame] | 920 | size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1; |
| 921 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 922 | bootpath = g_malloc(bootpathlen); |
Blue Swirl | 4fd37a9 | 2010-12-19 14:05:43 +0000 | [diff] [blame] | 923 | snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 924 | g_free(devpath); |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 925 | } else if (devpath) { |
| 926 | bootpath = devpath; |
| 927 | } else { |
Markus Armbruster | 1bf6ccd | 2011-11-08 10:58:00 +0100 | [diff] [blame] | 928 | assert(i->suffix); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 929 | bootpath = g_strdup(i->suffix); |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 930 | } |
| 931 | |
| 932 | if (total) { |
| 933 | list[total-1] = '\n'; |
| 934 | } |
| 935 | len = strlen(bootpath) + 1; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 936 | list = g_realloc(list, total + len); |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 937 | memcpy(&list[total], bootpath, len); |
| 938 | total += len; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 939 | g_free(bootpath); |
Gleb Natapov | 962630f | 2010-12-08 13:35:09 +0200 | [diff] [blame] | 940 | } |
| 941 | |
| 942 | *size = total; |
| 943 | |
| 944 | return list; |
| 945 | } |
| 946 | |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 947 | static void numa_add(const char *optarg) |
| 948 | { |
| 949 | char option[128]; |
| 950 | char *endptr; |
| 951 | unsigned long long value, endvalue; |
| 952 | int nodenr; |
| 953 | |
| 954 | optarg = get_opt_name(option, 128, optarg, ',') + 1; |
| 955 | if (!strcmp(option, "node")) { |
| 956 | if (get_param_value(option, 128, "nodeid", optarg) == 0) { |
| 957 | nodenr = nb_numa_nodes; |
| 958 | } else { |
| 959 | nodenr = strtoull(option, NULL, 10); |
| 960 | } |
| 961 | |
| 962 | if (get_param_value(option, 128, "mem", optarg) == 0) { |
| 963 | node_mem[nodenr] = 0; |
| 964 | } else { |
Jes Sorensen | 70b4f4b | 2011-01-05 11:41:02 +0100 | [diff] [blame] | 965 | int64_t sval; |
Markus Armbruster | c03417b | 2011-11-22 09:46:02 +0100 | [diff] [blame] | 966 | sval = strtosz(option, &endptr); |
| 967 | if (sval < 0 || *endptr) { |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 968 | fprintf(stderr, "qemu: invalid numa mem size: %s\n", optarg); |
| 969 | exit(1); |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 970 | } |
Jes Sorensen | 9f9b17a | 2010-10-21 17:15:46 +0200 | [diff] [blame] | 971 | node_mem[nodenr] = sval; |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 972 | } |
| 973 | if (get_param_value(option, 128, "cpus", optarg) == 0) { |
| 974 | node_cpumask[nodenr] = 0; |
| 975 | } else { |
| 976 | value = strtoull(option, &endptr, 10); |
| 977 | if (value >= 64) { |
| 978 | value = 63; |
| 979 | fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n"); |
| 980 | } else { |
| 981 | if (*endptr == '-') { |
| 982 | endvalue = strtoull(endptr+1, &endptr, 10); |
| 983 | if (endvalue >= 63) { |
| 984 | endvalue = 62; |
| 985 | fprintf(stderr, |
| 986 | "only 63 CPUs in NUMA mode supported.\n"); |
| 987 | } |
Paolo Bonzini | 0dfbd51 | 2010-02-04 14:31:50 +0100 | [diff] [blame] | 988 | value = (2ULL << endvalue) - (1ULL << value); |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 989 | } else { |
Paolo Bonzini | 0dfbd51 | 2010-02-04 14:31:50 +0100 | [diff] [blame] | 990 | value = 1ULL << value; |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 991 | } |
| 992 | } |
| 993 | node_cpumask[nodenr] = value; |
| 994 | } |
| 995 | nb_numa_nodes++; |
| 996 | } |
| 997 | return; |
| 998 | } |
| 999 | |
Andre Przywara | dc6b1c0 | 2009-08-19 15:42:40 +0200 | [diff] [blame] | 1000 | static void smp_parse(const char *optarg) |
| 1001 | { |
| 1002 | int smp, sockets = 0, threads = 0, cores = 0; |
| 1003 | char *endptr; |
| 1004 | char option[128]; |
| 1005 | |
| 1006 | smp = strtoul(optarg, &endptr, 10); |
| 1007 | if (endptr != optarg) { |
| 1008 | if (*endptr == ',') { |
| 1009 | endptr++; |
| 1010 | } |
| 1011 | } |
| 1012 | if (get_param_value(option, 128, "sockets", endptr) != 0) |
| 1013 | sockets = strtoull(option, NULL, 10); |
| 1014 | if (get_param_value(option, 128, "cores", endptr) != 0) |
| 1015 | cores = strtoull(option, NULL, 10); |
| 1016 | if (get_param_value(option, 128, "threads", endptr) != 0) |
| 1017 | threads = strtoull(option, NULL, 10); |
| 1018 | if (get_param_value(option, 128, "maxcpus", endptr) != 0) |
| 1019 | max_cpus = strtoull(option, NULL, 10); |
| 1020 | |
| 1021 | /* compute missing values, prefer sockets over cores over threads */ |
| 1022 | if (smp == 0 || sockets == 0) { |
| 1023 | sockets = sockets > 0 ? sockets : 1; |
| 1024 | cores = cores > 0 ? cores : 1; |
| 1025 | threads = threads > 0 ? threads : 1; |
| 1026 | if (smp == 0) { |
| 1027 | smp = cores * threads * sockets; |
Andre Przywara | dc6b1c0 | 2009-08-19 15:42:40 +0200 | [diff] [blame] | 1028 | } |
| 1029 | } else { |
| 1030 | if (cores == 0) { |
| 1031 | threads = threads > 0 ? threads : 1; |
| 1032 | cores = smp / (sockets * threads); |
| 1033 | } else { |
Joel Schopp | dca9816 | 2010-07-21 15:05:17 -0500 | [diff] [blame] | 1034 | threads = smp / (cores * sockets); |
Andre Przywara | dc6b1c0 | 2009-08-19 15:42:40 +0200 | [diff] [blame] | 1035 | } |
| 1036 | } |
| 1037 | smp_cpus = smp; |
| 1038 | smp_cores = cores > 0 ? cores : 1; |
| 1039 | smp_threads = threads > 0 ? threads : 1; |
| 1040 | if (max_cpus == 0) |
| 1041 | max_cpus = smp_cpus; |
| 1042 | } |
| 1043 | |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 1044 | /***********************************************************/ |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1045 | /* USB devices */ |
| 1046 | |
Markus Armbruster | fb08000 | 2010-05-28 15:38:44 +0200 | [diff] [blame] | 1047 | static int usb_device_add(const char *devname) |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1048 | { |
| 1049 | const char *p; |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1050 | USBDevice *dev = NULL; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1051 | |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1052 | if (!usb_enabled) |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1053 | return -1; |
| 1054 | |
Gerd Hoffmann | 0958b4c | 2009-10-26 15:56:45 +0100 | [diff] [blame] | 1055 | /* drivers with .usbdevice_name entry in USBDeviceInfo */ |
| 1056 | dev = usbdevice_create(devname); |
| 1057 | if (dev) |
| 1058 | goto done; |
| 1059 | |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1060 | /* the other ones */ |
Gerd Hoffmann | e447fc6 | 2011-06-01 14:41:59 +0200 | [diff] [blame] | 1061 | #ifndef CONFIG_LINUX |
| 1062 | /* only the linux version is qdev-ified, usb-bsd still needs this */ |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1063 | if (strstart(devname, "host:", &p)) { |
Jan Kiszka | 3741715 | 2012-02-27 15:18:47 +0100 | [diff] [blame] | 1064 | dev = usb_host_device_open(usb_bus_find(-1), p); |
Gerd Hoffmann | e447fc6 | 2011-06-01 14:41:59 +0200 | [diff] [blame] | 1065 | } else |
| 1066 | #endif |
| 1067 | if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) { |
Jan Kiszka | 3741715 | 2012-02-27 15:18:47 +0100 | [diff] [blame] | 1068 | dev = usb_bt_init(usb_bus_find(-1), |
| 1069 | devname[2] ? hci_init(p) |
| 1070 | : bt_new_hci(qemu_find_bt_vlan(0))); |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1071 | } else { |
| 1072 | return -1; |
| 1073 | } |
pbrook | 0d92ed3 | 2006-05-21 16:30:15 +0000 | [diff] [blame] | 1074 | if (!dev) |
| 1075 | return -1; |
| 1076 | |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1077 | done: |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1078 | return 0; |
| 1079 | } |
| 1080 | |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1081 | static int usb_device_del(const char *devname) |
| 1082 | { |
| 1083 | int bus_num, addr; |
| 1084 | const char *p; |
| 1085 | |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1086 | if (strstart(devname, "host:", &p)) |
| 1087 | return usb_host_device_close(p); |
| 1088 | |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1089 | if (!usb_enabled) |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1090 | return -1; |
| 1091 | |
| 1092 | p = strchr(devname, '.'); |
| 1093 | if (!p) |
| 1094 | return -1; |
| 1095 | bus_num = strtoul(devname, NULL, 0); |
| 1096 | addr = strtoul(p + 1, NULL, 0); |
| 1097 | |
Gerd Hoffmann | a5d2f72 | 2009-08-31 14:24:00 +0200 | [diff] [blame] | 1098 | return usb_device_delete_addr(bus_num, addr); |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1099 | } |
| 1100 | |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1101 | static int usb_parse(const char *cmdline) |
| 1102 | { |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1103 | int r; |
Markus Armbruster | fb08000 | 2010-05-28 15:38:44 +0200 | [diff] [blame] | 1104 | r = usb_device_add(cmdline); |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1105 | if (r < 0) { |
| 1106 | fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline); |
| 1107 | } |
| 1108 | return r; |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1109 | } |
| 1110 | |
Luiz Capitulino | d54908a | 2009-08-28 15:27:13 -0300 | [diff] [blame] | 1111 | void do_usb_add(Monitor *mon, const QDict *qdict) |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1112 | { |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1113 | const char *devname = qdict_get_str(qdict, "devname"); |
Markus Armbruster | fb08000 | 2010-05-28 15:38:44 +0200 | [diff] [blame] | 1114 | if (usb_device_add(devname) < 0) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 1115 | error_report("could not add USB device '%s'", devname); |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1116 | } |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1117 | } |
| 1118 | |
Luiz Capitulino | d54908a | 2009-08-28 15:27:13 -0300 | [diff] [blame] | 1119 | void do_usb_del(Monitor *mon, const QDict *qdict) |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1120 | { |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1121 | const char *devname = qdict_get_str(qdict, "devname"); |
| 1122 | if (usb_device_del(devname) < 0) { |
Markus Armbruster | 1ecda02 | 2010-02-18 17:25:24 +0100 | [diff] [blame] | 1123 | error_report("could not delete USB device '%s'", devname); |
Scott Tsai | 59d1c1c | 2009-12-23 04:30:18 +0800 | [diff] [blame] | 1124 | } |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1125 | } |
| 1126 | |
bellard | f7cce89 | 2004-12-08 22:21:25 +0000 | [diff] [blame] | 1127 | /***********************************************************/ |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1128 | /* PCMCIA/Cardbus */ |
| 1129 | |
| 1130 | static struct pcmcia_socket_entry_s { |
Paul Brook | bc24a22 | 2009-05-10 01:44:56 +0100 | [diff] [blame] | 1131 | PCMCIASocket *socket; |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1132 | struct pcmcia_socket_entry_s *next; |
| 1133 | } *pcmcia_sockets = 0; |
| 1134 | |
Paul Brook | bc24a22 | 2009-05-10 01:44:56 +0100 | [diff] [blame] | 1135 | void pcmcia_socket_register(PCMCIASocket *socket) |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1136 | { |
| 1137 | struct pcmcia_socket_entry_s *entry; |
| 1138 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1139 | entry = g_malloc(sizeof(struct pcmcia_socket_entry_s)); |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1140 | entry->socket = socket; |
| 1141 | entry->next = pcmcia_sockets; |
| 1142 | pcmcia_sockets = entry; |
| 1143 | } |
| 1144 | |
Paul Brook | bc24a22 | 2009-05-10 01:44:56 +0100 | [diff] [blame] | 1145 | void pcmcia_socket_unregister(PCMCIASocket *socket) |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1146 | { |
| 1147 | struct pcmcia_socket_entry_s *entry, **ptr; |
| 1148 | |
| 1149 | ptr = &pcmcia_sockets; |
| 1150 | for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr) |
| 1151 | if (entry->socket == socket) { |
| 1152 | *ptr = entry->next; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1153 | g_free(entry); |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1154 | } |
| 1155 | } |
| 1156 | |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1157 | void pcmcia_info(Monitor *mon) |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1158 | { |
| 1159 | struct pcmcia_socket_entry_s *iter; |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1160 | |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1161 | if (!pcmcia_sockets) |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1162 | monitor_printf(mon, "No PCMCIA sockets\n"); |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1163 | |
| 1164 | for (iter = pcmcia_sockets; iter; iter = iter->next) |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1165 | monitor_printf(mon, "%s: %s\n", iter->socket->slot_string, |
| 1166 | iter->socket->attached ? iter->socket->card_string : |
| 1167 | "Empty"); |
balrog | 201a51f | 2007-04-30 00:51:09 +0000 | [diff] [blame] | 1168 | } |
| 1169 | |
| 1170 | /***********************************************************/ |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 1171 | /* machine registration */ |
| 1172 | |
blueswir1 | bdaf78e | 2008-10-04 07:24:27 +0000 | [diff] [blame] | 1173 | static QEMUMachine *first_machine = NULL; |
aliguori | 6f338c3 | 2009-02-11 15:21:54 +0000 | [diff] [blame] | 1174 | QEMUMachine *current_machine = NULL; |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 1175 | |
| 1176 | int qemu_register_machine(QEMUMachine *m) |
| 1177 | { |
| 1178 | QEMUMachine **pm; |
| 1179 | pm = &first_machine; |
| 1180 | while (*pm != NULL) |
| 1181 | pm = &(*pm)->next; |
| 1182 | m->next = NULL; |
| 1183 | *pm = m; |
| 1184 | return 0; |
| 1185 | } |
| 1186 | |
pbrook | 9596ebb | 2007-11-18 01:44:38 +0000 | [diff] [blame] | 1187 | static QEMUMachine *find_machine(const char *name) |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 1188 | { |
| 1189 | QEMUMachine *m; |
| 1190 | |
| 1191 | for(m = first_machine; m != NULL; m = m->next) { |
| 1192 | if (!strcmp(m->name, name)) |
| 1193 | return m; |
Mark McLoughlin | 3f6599e | 2009-07-22 10:02:50 +0100 | [diff] [blame] | 1194 | if (m->alias && !strcmp(m->alias, name)) |
| 1195 | return m; |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 1196 | } |
| 1197 | return NULL; |
| 1198 | } |
| 1199 | |
Jordan Justen | 2c8cffa | 2012-02-21 23:18:50 -0800 | [diff] [blame] | 1200 | QEMUMachine *find_default_machine(void) |
Anthony Liguori | 0c25743 | 2009-05-21 20:41:01 -0500 | [diff] [blame] | 1201 | { |
| 1202 | QEMUMachine *m; |
| 1203 | |
| 1204 | for(m = first_machine; m != NULL; m = m->next) { |
| 1205 | if (m->is_default) { |
| 1206 | return m; |
| 1207 | } |
| 1208 | } |
| 1209 | return NULL; |
| 1210 | } |
| 1211 | |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 1212 | /***********************************************************/ |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1213 | /* main execution loop */ |
| 1214 | |
pbrook | 9596ebb | 2007-11-18 01:44:38 +0000 | [diff] [blame] | 1215 | static void gui_update(void *opaque) |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1216 | { |
aliguori | 7d957bd | 2009-01-15 22:14:11 +0000 | [diff] [blame] | 1217 | uint64_t interval = GUI_REFRESH_INTERVAL; |
ths | 740733b | 2007-06-08 01:57:56 +0000 | [diff] [blame] | 1218 | DisplayState *ds = opaque; |
aliguori | 7d957bd | 2009-01-15 22:14:11 +0000 | [diff] [blame] | 1219 | DisplayChangeListener *dcl = ds->listeners; |
| 1220 | |
| 1221 | dpy_refresh(ds); |
| 1222 | |
| 1223 | while (dcl != NULL) { |
| 1224 | if (dcl->gui_timer_interval && |
| 1225 | dcl->gui_timer_interval < interval) |
| 1226 | interval = dcl->gui_timer_interval; |
| 1227 | dcl = dcl->next; |
| 1228 | } |
Paolo Bonzini | 7bd427d | 2011-03-11 16:47:48 +0100 | [diff] [blame] | 1229 | qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock_ms(rt_clock)); |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1230 | } |
| 1231 | |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1232 | struct vm_change_state_entry { |
| 1233 | VMChangeStateHandler *cb; |
| 1234 | void *opaque; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1235 | QLIST_ENTRY (vm_change_state_entry) entries; |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1236 | }; |
| 1237 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1238 | static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head; |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1239 | |
| 1240 | VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb, |
| 1241 | void *opaque) |
| 1242 | { |
| 1243 | VMChangeStateEntry *e; |
| 1244 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1245 | e = g_malloc0(sizeof (*e)); |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1246 | |
| 1247 | e->cb = cb; |
| 1248 | e->opaque = opaque; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1249 | QLIST_INSERT_HEAD(&vm_change_state_head, e, entries); |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1250 | return e; |
| 1251 | } |
| 1252 | |
| 1253 | void qemu_del_vm_change_state_handler(VMChangeStateEntry *e) |
| 1254 | { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1255 | QLIST_REMOVE (e, entries); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1256 | g_free (e); |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1257 | } |
| 1258 | |
Luiz Capitulino | 1dfb4dd | 2011-07-29 14:26:33 -0300 | [diff] [blame] | 1259 | void vm_state_notify(int running, RunState state) |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1260 | { |
| 1261 | VMChangeStateEntry *e; |
| 1262 | |
Luiz Capitulino | 1dfb4dd | 2011-07-29 14:26:33 -0300 | [diff] [blame] | 1263 | trace_vm_state_notify(running, state); |
Stefan Hajnoczi | 94b0b5f | 2010-11-16 12:20:25 +0000 | [diff] [blame] | 1264 | |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1265 | for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) { |
Luiz Capitulino | 1dfb4dd | 2011-07-29 14:26:33 -0300 | [diff] [blame] | 1266 | e->cb(e->opaque, running, state); |
bellard | 0bd4885 | 2005-11-11 00:00:47 +0000 | [diff] [blame] | 1267 | } |
| 1268 | } |
| 1269 | |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1270 | void vm_start(void) |
| 1271 | { |
Luiz Capitulino | 1354869 | 2011-07-29 15:36:43 -0300 | [diff] [blame] | 1272 | if (!runstate_is_running()) { |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1273 | cpu_enable_ticks(); |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 1274 | runstate_set(RUN_STATE_RUNNING); |
| 1275 | vm_state_notify(1, RUN_STATE_RUNNING); |
aliguori | d6dc3d4 | 2009-04-24 18:04:07 +0000 | [diff] [blame] | 1276 | resume_all_vcpus(); |
Luiz Capitulino | 6ed2c48 | 2010-04-27 20:35:59 -0300 | [diff] [blame] | 1277 | monitor_protocol_event(QEVENT_RESUME, NULL); |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 1278 | } |
| 1279 | } |
| 1280 | |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1281 | /* reset/shutdown handler */ |
| 1282 | |
| 1283 | typedef struct QEMUResetEntry { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1284 | QTAILQ_ENTRY(QEMUResetEntry) entry; |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1285 | QEMUResetHandler *func; |
| 1286 | void *opaque; |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1287 | } QEMUResetEntry; |
| 1288 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1289 | static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers = |
| 1290 | QTAILQ_HEAD_INITIALIZER(reset_handlers); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1291 | static int reset_requested; |
Gleb Natapov | f64622c | 2011-03-15 13:56:04 +0200 | [diff] [blame] | 1292 | static int shutdown_requested, shutdown_signal = -1; |
| 1293 | static pid_t shutdown_pid; |
bellard | 3475187 | 2005-07-02 14:31:34 +0000 | [diff] [blame] | 1294 | static int powerdown_requested; |
Jan Kiszka | 8cf7171 | 2011-02-07 12:19:16 +0100 | [diff] [blame] | 1295 | static int debug_requested; |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1296 | static int suspend_requested; |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1297 | static NotifierList suspend_notifiers = |
| 1298 | NOTIFIER_LIST_INITIALIZER(suspend_notifiers); |
| 1299 | static NotifierList wakeup_notifiers = |
| 1300 | NOTIFIER_LIST_INITIALIZER(wakeup_notifiers); |
| 1301 | static uint32_t wakeup_reason_mask = ~0; |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 1302 | static RunState vmstop_requested = RUN_STATE_MAX; |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1303 | |
Anthony PERARD | 1291eb3 | 2010-07-22 15:52:48 +0100 | [diff] [blame] | 1304 | int qemu_shutdown_requested_get(void) |
| 1305 | { |
| 1306 | return shutdown_requested; |
| 1307 | } |
| 1308 | |
| 1309 | int qemu_reset_requested_get(void) |
| 1310 | { |
| 1311 | return reset_requested; |
| 1312 | } |
| 1313 | |
aurel32 | cf7a2fe | 2008-03-18 06:53:05 +0000 | [diff] [blame] | 1314 | int qemu_shutdown_requested(void) |
| 1315 | { |
| 1316 | int r = shutdown_requested; |
| 1317 | shutdown_requested = 0; |
| 1318 | return r; |
| 1319 | } |
| 1320 | |
Gleb Natapov | f64622c | 2011-03-15 13:56:04 +0200 | [diff] [blame] | 1321 | void qemu_kill_report(void) |
| 1322 | { |
Anthony Liguori | c7f0f3b | 2012-03-28 15:42:02 +0200 | [diff] [blame] | 1323 | if (!qtest_enabled() && shutdown_signal != -1) { |
Peter Maydell | f1d3fb0 | 2011-03-30 22:03:38 +0100 | [diff] [blame] | 1324 | fprintf(stderr, "qemu: terminating on signal %d", shutdown_signal); |
| 1325 | if (shutdown_pid == 0) { |
| 1326 | /* This happens for eg ^C at the terminal, so it's worth |
| 1327 | * avoiding printing an odd message in that case. |
| 1328 | */ |
| 1329 | fputc('\n', stderr); |
| 1330 | } else { |
Andreas Färber | 953ffe0 | 2011-06-02 19:58:06 +0200 | [diff] [blame] | 1331 | fprintf(stderr, " from pid " FMT_pid "\n", shutdown_pid); |
Peter Maydell | f1d3fb0 | 2011-03-30 22:03:38 +0100 | [diff] [blame] | 1332 | } |
Gleb Natapov | f64622c | 2011-03-15 13:56:04 +0200 | [diff] [blame] | 1333 | shutdown_signal = -1; |
| 1334 | } |
| 1335 | } |
| 1336 | |
aurel32 | cf7a2fe | 2008-03-18 06:53:05 +0000 | [diff] [blame] | 1337 | int qemu_reset_requested(void) |
| 1338 | { |
| 1339 | int r = reset_requested; |
| 1340 | reset_requested = 0; |
| 1341 | return r; |
| 1342 | } |
| 1343 | |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1344 | static int qemu_suspend_requested(void) |
| 1345 | { |
| 1346 | int r = suspend_requested; |
| 1347 | suspend_requested = 0; |
| 1348 | return r; |
| 1349 | } |
| 1350 | |
aurel32 | cf7a2fe | 2008-03-18 06:53:05 +0000 | [diff] [blame] | 1351 | int qemu_powerdown_requested(void) |
| 1352 | { |
| 1353 | int r = powerdown_requested; |
| 1354 | powerdown_requested = 0; |
| 1355 | return r; |
| 1356 | } |
| 1357 | |
aliguori | e568902 | 2009-04-24 18:03:54 +0000 | [diff] [blame] | 1358 | static int qemu_debug_requested(void) |
| 1359 | { |
| 1360 | int r = debug_requested; |
| 1361 | debug_requested = 0; |
| 1362 | return r; |
| 1363 | } |
| 1364 | |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 1365 | /* We use RUN_STATE_MAX but any invalid value will do */ |
Luiz Capitulino | 0d45b70 | 2011-09-30 14:27:11 -0300 | [diff] [blame] | 1366 | static bool qemu_vmstop_requested(RunState *r) |
aliguori | 6e29f5d | 2009-04-24 18:04:02 +0000 | [diff] [blame] | 1367 | { |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 1368 | if (vmstop_requested < RUN_STATE_MAX) { |
Luiz Capitulino | 0d45b70 | 2011-09-30 14:27:11 -0300 | [diff] [blame] | 1369 | *r = vmstop_requested; |
Luiz Capitulino | 0461d5a | 2011-09-30 14:45:27 -0300 | [diff] [blame] | 1370 | vmstop_requested = RUN_STATE_MAX; |
Luiz Capitulino | 0d45b70 | 2011-09-30 14:27:11 -0300 | [diff] [blame] | 1371 | return true; |
| 1372 | } |
| 1373 | |
| 1374 | return false; |
aliguori | 6e29f5d | 2009-04-24 18:04:02 +0000 | [diff] [blame] | 1375 | } |
| 1376 | |
Jan Kiszka | a08d436 | 2009-06-27 09:25:07 +0200 | [diff] [blame] | 1377 | void qemu_register_reset(QEMUResetHandler *func, void *opaque) |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1378 | { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1379 | QEMUResetEntry *re = g_malloc0(sizeof(QEMUResetEntry)); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1380 | |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1381 | re->func = func; |
| 1382 | re->opaque = opaque; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1383 | QTAILQ_INSERT_TAIL(&reset_handlers, re, entry); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1384 | } |
| 1385 | |
Jan Kiszka | dda9b29 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 1386 | void qemu_unregister_reset(QEMUResetHandler *func, void *opaque) |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1387 | { |
| 1388 | QEMUResetEntry *re; |
| 1389 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1390 | QTAILQ_FOREACH(re, &reset_handlers, entry) { |
Jan Kiszka | dda9b29 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 1391 | if (re->func == func && re->opaque == opaque) { |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1392 | QTAILQ_REMOVE(&reset_handlers, re, entry); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1393 | g_free(re); |
Jan Kiszka | dda9b29 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 1394 | return; |
| 1395 | } |
| 1396 | } |
| 1397 | } |
| 1398 | |
Jan Kiszka | e063eb1 | 2011-06-14 18:29:43 +0200 | [diff] [blame] | 1399 | void qemu_system_reset(bool report) |
Jan Kiszka | dda9b29 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 1400 | { |
| 1401 | QEMUResetEntry *re, *nre; |
| 1402 | |
| 1403 | /* reset all devices */ |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1404 | QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) { |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1405 | re->func(re->opaque); |
| 1406 | } |
Jan Kiszka | e063eb1 | 2011-06-14 18:29:43 +0200 | [diff] [blame] | 1407 | if (report) { |
| 1408 | monitor_protocol_event(QEVENT_RESET, NULL); |
| 1409 | } |
Jan Kiszka | ea375f9 | 2010-03-01 19:10:30 +0100 | [diff] [blame] | 1410 | cpu_synchronize_all_post_reset(); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1411 | } |
| 1412 | |
| 1413 | void qemu_system_reset_request(void) |
| 1414 | { |
bellard | d1beab8 | 2006-10-02 19:44:22 +0000 | [diff] [blame] | 1415 | if (no_reboot) { |
| 1416 | shutdown_requested = 1; |
| 1417 | } else { |
| 1418 | reset_requested = 1; |
| 1419 | } |
Jan Kiszka | b4a3d96 | 2011-02-01 22:15:43 +0100 | [diff] [blame] | 1420 | cpu_stop_current(); |
aliguori | d9f75a4 | 2009-04-24 18:03:11 +0000 | [diff] [blame] | 1421 | qemu_notify_event(); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1422 | } |
| 1423 | |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1424 | static void qemu_system_suspend(void) |
| 1425 | { |
| 1426 | pause_all_vcpus(); |
| 1427 | notifier_list_notify(&suspend_notifiers, NULL); |
Luiz Capitulino | ad02b96 | 2012-04-27 13:33:36 -0300 | [diff] [blame] | 1428 | runstate_set(RUN_STATE_SUSPENDED); |
Gerd Hoffmann | 53370b7 | 2012-02-23 13:45:26 +0100 | [diff] [blame] | 1429 | monitor_protocol_event(QEVENT_SUSPEND, NULL); |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1430 | } |
| 1431 | |
| 1432 | void qemu_system_suspend_request(void) |
| 1433 | { |
Luiz Capitulino | 9abc62f | 2012-04-27 14:31:12 -0300 | [diff] [blame] | 1434 | if (runstate_check(RUN_STATE_SUSPENDED)) { |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1435 | return; |
| 1436 | } |
| 1437 | suspend_requested = 1; |
| 1438 | cpu_stop_current(); |
| 1439 | qemu_notify_event(); |
| 1440 | } |
| 1441 | |
| 1442 | void qemu_register_suspend_notifier(Notifier *notifier) |
| 1443 | { |
| 1444 | notifier_list_add(&suspend_notifiers, notifier); |
| 1445 | } |
| 1446 | |
| 1447 | void qemu_system_wakeup_request(WakeupReason reason) |
| 1448 | { |
Luiz Capitulino | 9abc62f | 2012-04-27 14:31:12 -0300 | [diff] [blame] | 1449 | if (!runstate_check(RUN_STATE_SUSPENDED)) { |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1450 | return; |
| 1451 | } |
| 1452 | if (!(wakeup_reason_mask & (1 << reason))) { |
| 1453 | return; |
| 1454 | } |
Luiz Capitulino | ad02b96 | 2012-04-27 13:33:36 -0300 | [diff] [blame] | 1455 | runstate_set(RUN_STATE_RUNNING); |
Gerd Hoffmann | 53370b7 | 2012-02-23 13:45:26 +0100 | [diff] [blame] | 1456 | monitor_protocol_event(QEVENT_WAKEUP, NULL); |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1457 | notifier_list_notify(&wakeup_notifiers, &reason); |
| 1458 | reset_requested = 1; |
| 1459 | qemu_notify_event(); |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1460 | } |
| 1461 | |
| 1462 | void qemu_system_wakeup_enable(WakeupReason reason, bool enabled) |
| 1463 | { |
| 1464 | if (enabled) { |
| 1465 | wakeup_reason_mask |= (1 << reason); |
| 1466 | } else { |
| 1467 | wakeup_reason_mask &= ~(1 << reason); |
| 1468 | } |
| 1469 | } |
| 1470 | |
| 1471 | void qemu_register_wakeup_notifier(Notifier *notifier) |
| 1472 | { |
| 1473 | notifier_list_add(&wakeup_notifiers, notifier); |
| 1474 | } |
| 1475 | |
Gleb Natapov | f64622c | 2011-03-15 13:56:04 +0200 | [diff] [blame] | 1476 | void qemu_system_killed(int signal, pid_t pid) |
| 1477 | { |
| 1478 | shutdown_signal = signal; |
| 1479 | shutdown_pid = pid; |
Kevin Wolf | d9389b9 | 2011-09-14 15:38:40 +0200 | [diff] [blame] | 1480 | no_shutdown = 0; |
Gleb Natapov | f64622c | 2011-03-15 13:56:04 +0200 | [diff] [blame] | 1481 | qemu_system_shutdown_request(); |
| 1482 | } |
| 1483 | |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1484 | void qemu_system_shutdown_request(void) |
| 1485 | { |
| 1486 | shutdown_requested = 1; |
aliguori | d9f75a4 | 2009-04-24 18:03:11 +0000 | [diff] [blame] | 1487 | qemu_notify_event(); |
bellard | bb0c672 | 2004-06-20 12:37:32 +0000 | [diff] [blame] | 1488 | } |
| 1489 | |
bellard | 3475187 | 2005-07-02 14:31:34 +0000 | [diff] [blame] | 1490 | void qemu_system_powerdown_request(void) |
| 1491 | { |
| 1492 | powerdown_requested = 1; |
aliguori | d9f75a4 | 2009-04-24 18:03:11 +0000 | [diff] [blame] | 1493 | qemu_notify_event(); |
| 1494 | } |
| 1495 | |
Jan Kiszka | 8cf7171 | 2011-02-07 12:19:16 +0100 | [diff] [blame] | 1496 | void qemu_system_debug_request(void) |
| 1497 | { |
| 1498 | debug_requested = 1; |
Jan Kiszka | 83f338f | 2011-02-07 12:19:17 +0100 | [diff] [blame] | 1499 | qemu_notify_event(); |
Jan Kiszka | 8cf7171 | 2011-02-07 12:19:16 +0100 | [diff] [blame] | 1500 | } |
| 1501 | |
Luiz Capitulino | 1dfb4dd | 2011-07-29 14:26:33 -0300 | [diff] [blame] | 1502 | void qemu_system_vmstop_request(RunState state) |
Jan Kiszka | 8cf7171 | 2011-02-07 12:19:16 +0100 | [diff] [blame] | 1503 | { |
Luiz Capitulino | 1dfb4dd | 2011-07-29 14:26:33 -0300 | [diff] [blame] | 1504 | vmstop_requested = state; |
Jan Kiszka | 8cf7171 | 2011-02-07 12:19:16 +0100 | [diff] [blame] | 1505 | qemu_notify_event(); |
| 1506 | } |
| 1507 | |
Blue Swirl | d9c3231 | 2009-08-09 08:42:19 +0000 | [diff] [blame] | 1508 | qemu_irq qemu_system_powerdown; |
| 1509 | |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 1510 | static bool main_loop_should_exit(void) |
| 1511 | { |
| 1512 | RunState r; |
| 1513 | if (qemu_debug_requested()) { |
| 1514 | vm_stop(RUN_STATE_DEBUG); |
| 1515 | } |
Gerd Hoffmann | 95b363b | 2012-02-23 13:45:19 +0100 | [diff] [blame] | 1516 | if (qemu_suspend_requested()) { |
| 1517 | qemu_system_suspend(); |
| 1518 | } |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 1519 | if (qemu_shutdown_requested()) { |
| 1520 | qemu_kill_report(); |
| 1521 | monitor_protocol_event(QEVENT_SHUTDOWN, NULL); |
| 1522 | if (no_shutdown) { |
| 1523 | vm_stop(RUN_STATE_SHUTDOWN); |
| 1524 | } else { |
| 1525 | return true; |
| 1526 | } |
| 1527 | } |
| 1528 | if (qemu_reset_requested()) { |
| 1529 | pause_all_vcpus(); |
| 1530 | cpu_synchronize_all_states(); |
| 1531 | qemu_system_reset(VMRESET_REPORT); |
| 1532 | resume_all_vcpus(); |
| 1533 | if (runstate_check(RUN_STATE_INTERNAL_ERROR) || |
| 1534 | runstate_check(RUN_STATE_SHUTDOWN)) { |
| 1535 | runstate_set(RUN_STATE_PAUSED); |
| 1536 | } |
| 1537 | } |
| 1538 | if (qemu_powerdown_requested()) { |
| 1539 | monitor_protocol_event(QEVENT_POWERDOWN, NULL); |
| 1540 | qemu_irq_raise(qemu_system_powerdown); |
| 1541 | } |
| 1542 | if (qemu_vmstop_requested(&r)) { |
| 1543 | vm_stop(r); |
| 1544 | } |
| 1545 | return false; |
| 1546 | } |
| 1547 | |
aliguori | 43b9685 | 2009-04-24 18:03:33 +0000 | [diff] [blame] | 1548 | static void main_loop(void) |
| 1549 | { |
Jan Kiszka | c9f711a | 2011-08-22 17:46:02 +0200 | [diff] [blame] | 1550 | bool nonblocking; |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 1551 | int last_io = 0; |
Jan Kiszka | 8e1b90e | 2011-02-01 22:15:46 +0100 | [diff] [blame] | 1552 | #ifdef CONFIG_PROFILER |
| 1553 | int64_t ti; |
| 1554 | #endif |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 1555 | do { |
Jan Kiszka | c9f711a | 2011-08-22 17:46:02 +0200 | [diff] [blame] | 1556 | nonblocking = !kvm_enabled() && last_io > 0; |
aliguori | 43b9685 | 2009-04-24 18:03:33 +0000 | [diff] [blame] | 1557 | #ifdef CONFIG_PROFILER |
Jan Kiszka | 46481d3 | 2011-02-01 22:15:47 +0100 | [diff] [blame] | 1558 | ti = profile_getclock(); |
aliguori | 43b9685 | 2009-04-24 18:03:33 +0000 | [diff] [blame] | 1559 | #endif |
Jan Kiszka | c9f711a | 2011-08-22 17:46:02 +0200 | [diff] [blame] | 1560 | last_io = main_loop_wait(nonblocking); |
aliguori | 43b9685 | 2009-04-24 18:03:33 +0000 | [diff] [blame] | 1561 | #ifdef CONFIG_PROFILER |
Jan Kiszka | 46481d3 | 2011-02-01 22:15:47 +0100 | [diff] [blame] | 1562 | dev_time += profile_getclock() - ti; |
aliguori | 43b9685 | 2009-04-24 18:03:33 +0000 | [diff] [blame] | 1563 | #endif |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 1564 | } while (!main_loop_should_exit()); |
bellard | b4608c0 | 2003-06-27 17:34:32 +0000 | [diff] [blame] | 1565 | } |
| 1566 | |
pbrook | 9bd7e6d | 2009-04-07 22:58:45 +0000 | [diff] [blame] | 1567 | static void version(void) |
| 1568 | { |
Thomas Monjalon | f75ca1a | 2010-04-28 14:42:01 +0200 | [diff] [blame] | 1569 | printf("QEMU emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"); |
pbrook | 9bd7e6d | 2009-04-07 22:58:45 +0000 | [diff] [blame] | 1570 | } |
| 1571 | |
ths | 15f8220 | 2007-06-29 23:26:08 +0000 | [diff] [blame] | 1572 | static void help(int exitcode) |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 1573 | { |
Michael Ellerman | a3adb7a | 2011-12-19 17:19:31 +1100 | [diff] [blame] | 1574 | version(); |
| 1575 | printf("usage: %s [options] [disk_image]\n\n" |
| 1576 | "'disk_image' is a raw hard disk image for IDE hard disk 0\n\n", |
| 1577 | error_get_progname()); |
| 1578 | |
Michael Ellerman | 77bd111 | 2011-12-19 17:19:30 +1100 | [diff] [blame] | 1579 | #define QEMU_OPTIONS_GENERATE_HELP |
| 1580 | #include "qemu-options-wrapper.h" |
Michael Ellerman | a3adb7a | 2011-12-19 17:19:31 +1100 | [diff] [blame] | 1581 | |
| 1582 | printf("\nDuring emulation, the following keys are useful:\n" |
malc | 3f020d7 | 2010-02-08 12:04:56 +0300 | [diff] [blame] | 1583 | "ctrl-alt-f toggle full screen\n" |
| 1584 | "ctrl-alt-n switch to virtual console 'n'\n" |
| 1585 | "ctrl-alt toggle mouse and keyboard grab\n" |
| 1586 | "\n" |
Michael Ellerman | a3adb7a | 2011-12-19 17:19:31 +1100 | [diff] [blame] | 1587 | "When using -nographic, press 'ctrl-a h' to get some help.\n"); |
| 1588 | |
ths | 15f8220 | 2007-06-29 23:26:08 +0000 | [diff] [blame] | 1589 | exit(exitcode); |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 1590 | } |
| 1591 | |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 1592 | #define HAS_ARG 0x0001 |
| 1593 | |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 1594 | typedef struct QEMUOption { |
| 1595 | const char *name; |
| 1596 | int flags; |
| 1597 | int index; |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 1598 | uint32_t arch_mask; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 1599 | } QEMUOption; |
| 1600 | |
blueswir1 | dbed7e4 | 2008-10-01 19:38:09 +0000 | [diff] [blame] | 1601 | static const QEMUOption qemu_options[] = { |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 1602 | { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL }, |
Michael Ellerman | 77bd111 | 2011-12-19 17:19:30 +1100 | [diff] [blame] | 1603 | #define QEMU_OPTIONS_GENERATE_OPTIONS |
| 1604 | #include "qemu-options-wrapper.h" |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 1605 | { NULL }, |
bellard | fc01f7e | 2003-06-30 10:03:06 +0000 | [diff] [blame] | 1606 | }; |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 1607 | |
| 1608 | static bool vga_available(void) |
| 1609 | { |
| 1610 | return qdev_exists("VGA") || qdev_exists("isa-vga"); |
| 1611 | } |
| 1612 | |
| 1613 | static bool cirrus_vga_available(void) |
| 1614 | { |
| 1615 | return qdev_exists("cirrus-vga") || qdev_exists("isa-cirrus-vga"); |
| 1616 | } |
| 1617 | |
| 1618 | static bool vmware_vga_available(void) |
| 1619 | { |
| 1620 | return qdev_exists("vmware-svga"); |
| 1621 | } |
| 1622 | |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1623 | static void select_vgahw (const char *p) |
| 1624 | { |
| 1625 | const char *opts; |
| 1626 | |
Zachary Amsden | 8617675 | 2009-07-30 00:15:02 -1000 | [diff] [blame] | 1627 | vga_interface_type = VGA_NONE; |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1628 | if (strstart(p, "std", &opts)) { |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 1629 | if (vga_available()) { |
| 1630 | vga_interface_type = VGA_STD; |
| 1631 | } else { |
| 1632 | fprintf(stderr, "Error: standard VGA not available\n"); |
| 1633 | exit(0); |
| 1634 | } |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1635 | } else if (strstart(p, "cirrus", &opts)) { |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 1636 | if (cirrus_vga_available()) { |
| 1637 | vga_interface_type = VGA_CIRRUS; |
| 1638 | } else { |
| 1639 | fprintf(stderr, "Error: Cirrus VGA not available\n"); |
| 1640 | exit(0); |
| 1641 | } |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1642 | } else if (strstart(p, "vmware", &opts)) { |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 1643 | if (vmware_vga_available()) { |
| 1644 | vga_interface_type = VGA_VMWARE; |
| 1645 | } else { |
| 1646 | fprintf(stderr, "Error: VMWare SVGA not available\n"); |
| 1647 | exit(0); |
| 1648 | } |
aliguori | 94909d9 | 2009-04-22 15:19:53 +0000 | [diff] [blame] | 1649 | } else if (strstart(p, "xenfb", &opts)) { |
Zachary Amsden | 8617675 | 2009-07-30 00:15:02 -1000 | [diff] [blame] | 1650 | vga_interface_type = VGA_XENFB; |
Gerd Hoffmann | a19cbfb | 2010-04-27 11:50:11 +0200 | [diff] [blame] | 1651 | } else if (strstart(p, "qxl", &opts)) { |
| 1652 | vga_interface_type = VGA_QXL; |
aliguori | 28b85ed | 2009-04-22 15:19:48 +0000 | [diff] [blame] | 1653 | } else if (!strstart(p, "none", &opts)) { |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1654 | invalid_vga: |
| 1655 | fprintf(stderr, "Unknown vga type: %s\n", p); |
| 1656 | exit(1); |
| 1657 | } |
malc | cb5a7aa | 2008-09-28 00:42:12 +0000 | [diff] [blame] | 1658 | while (*opts) { |
| 1659 | const char *nextopt; |
| 1660 | |
| 1661 | if (strstart(opts, ",retrace=", &nextopt)) { |
| 1662 | opts = nextopt; |
| 1663 | if (strstart(opts, "dumb", &nextopt)) |
| 1664 | vga_retrace_method = VGA_RETRACE_DUMB; |
| 1665 | else if (strstart(opts, "precise", &nextopt)) |
| 1666 | vga_retrace_method = VGA_RETRACE_PRECISE; |
| 1667 | else goto invalid_vga; |
| 1668 | } else goto invalid_vga; |
| 1669 | opts = nextopt; |
| 1670 | } |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 1671 | } |
| 1672 | |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1673 | static DisplayType select_display(const char *p) |
| 1674 | { |
| 1675 | const char *opts; |
| 1676 | DisplayType display = DT_DEFAULT; |
| 1677 | |
| 1678 | if (strstart(p, "sdl", &opts)) { |
| 1679 | #ifdef CONFIG_SDL |
| 1680 | display = DT_SDL; |
| 1681 | while (*opts) { |
| 1682 | const char *nextopt; |
| 1683 | |
| 1684 | if (strstart(opts, ",frame=", &nextopt)) { |
| 1685 | opts = nextopt; |
| 1686 | if (strstart(opts, "on", &nextopt)) { |
| 1687 | no_frame = 0; |
| 1688 | } else if (strstart(opts, "off", &nextopt)) { |
| 1689 | no_frame = 1; |
| 1690 | } else { |
Peter Maydell | 0517553 | 2011-03-23 03:40:57 +0000 | [diff] [blame] | 1691 | goto invalid_sdl_args; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1692 | } |
| 1693 | } else if (strstart(opts, ",alt_grab=", &nextopt)) { |
| 1694 | opts = nextopt; |
| 1695 | if (strstart(opts, "on", &nextopt)) { |
| 1696 | alt_grab = 1; |
| 1697 | } else if (strstart(opts, "off", &nextopt)) { |
| 1698 | alt_grab = 0; |
| 1699 | } else { |
Peter Maydell | 0517553 | 2011-03-23 03:40:57 +0000 | [diff] [blame] | 1700 | goto invalid_sdl_args; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1701 | } |
| 1702 | } else if (strstart(opts, ",ctrl_grab=", &nextopt)) { |
| 1703 | opts = nextopt; |
| 1704 | if (strstart(opts, "on", &nextopt)) { |
| 1705 | ctrl_grab = 1; |
| 1706 | } else if (strstart(opts, "off", &nextopt)) { |
| 1707 | ctrl_grab = 0; |
| 1708 | } else { |
Peter Maydell | 0517553 | 2011-03-23 03:40:57 +0000 | [diff] [blame] | 1709 | goto invalid_sdl_args; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1710 | } |
| 1711 | } else if (strstart(opts, ",window_close=", &nextopt)) { |
| 1712 | opts = nextopt; |
| 1713 | if (strstart(opts, "on", &nextopt)) { |
| 1714 | no_quit = 0; |
| 1715 | } else if (strstart(opts, "off", &nextopt)) { |
| 1716 | no_quit = 1; |
| 1717 | } else { |
Peter Maydell | 0517553 | 2011-03-23 03:40:57 +0000 | [diff] [blame] | 1718 | goto invalid_sdl_args; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1719 | } |
| 1720 | } else { |
Peter Maydell | 0517553 | 2011-03-23 03:40:57 +0000 | [diff] [blame] | 1721 | invalid_sdl_args: |
| 1722 | fprintf(stderr, "Invalid SDL option string: %s\n", p); |
| 1723 | exit(1); |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1724 | } |
| 1725 | opts = nextopt; |
| 1726 | } |
| 1727 | #else |
| 1728 | fprintf(stderr, "SDL support is disabled\n"); |
| 1729 | exit(1); |
| 1730 | #endif |
Jes Sorensen | 3264ff1 | 2011-03-16 13:33:33 +0100 | [diff] [blame] | 1731 | } else if (strstart(p, "vnc", &opts)) { |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 1732 | #ifdef CONFIG_VNC |
Jes Sorensen | 3264ff1 | 2011-03-16 13:33:33 +0100 | [diff] [blame] | 1733 | display_remote++; |
| 1734 | |
| 1735 | if (*opts) { |
| 1736 | const char *nextopt; |
| 1737 | |
| 1738 | if (strstart(opts, "=", &nextopt)) { |
| 1739 | vnc_display = nextopt; |
| 1740 | } |
| 1741 | } |
| 1742 | if (!vnc_display) { |
| 1743 | fprintf(stderr, "VNC requires a display argument vnc=<display>\n"); |
| 1744 | exit(1); |
| 1745 | } |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 1746 | #else |
| 1747 | fprintf(stderr, "VNC support is disabled\n"); |
| 1748 | exit(1); |
| 1749 | #endif |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1750 | } else if (strstart(p, "curses", &opts)) { |
| 1751 | #ifdef CONFIG_CURSES |
| 1752 | display = DT_CURSES; |
| 1753 | #else |
| 1754 | fprintf(stderr, "Curses support is disabled\n"); |
| 1755 | exit(1); |
| 1756 | #endif |
Jes Sorensen | 4171d32 | 2011-03-16 13:33:32 +0100 | [diff] [blame] | 1757 | } else if (strstart(p, "none", &opts)) { |
| 1758 | display = DT_NONE; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1759 | } else { |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 1760 | fprintf(stderr, "Unknown display type: %s\n", p); |
| 1761 | exit(1); |
| 1762 | } |
| 1763 | |
| 1764 | return display; |
| 1765 | } |
| 1766 | |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 1767 | static int balloon_parse(const char *arg) |
| 1768 | { |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1769 | QemuOpts *opts; |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 1770 | |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1771 | if (strcmp(arg, "none") == 0) { |
| 1772 | return 0; |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 1773 | } |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1774 | |
| 1775 | if (!strncmp(arg, "virtio", 6)) { |
| 1776 | if (arg[6] == ',') { |
| 1777 | /* have params -> parse them */ |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 1778 | opts = qemu_opts_parse(qemu_find_opts("device"), arg+7, 0); |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1779 | if (!opts) |
| 1780 | return -1; |
| 1781 | } else { |
| 1782 | /* create empty opts */ |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 1783 | opts = qemu_opts_create(qemu_find_opts("device"), NULL, 0, NULL); |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1784 | } |
Alexander Graf | 29f82b3 | 2011-03-29 15:29:29 +0200 | [diff] [blame] | 1785 | qemu_opt_set(opts, "driver", "virtio-balloon"); |
Gerd Hoffmann | 382f074 | 2009-08-14 10:34:22 +0200 | [diff] [blame] | 1786 | return 0; |
| 1787 | } |
| 1788 | |
| 1789 | return -1; |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 1790 | } |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 1791 | |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 1792 | char *qemu_find_file(int type, const char *name) |
| 1793 | { |
| 1794 | int len; |
| 1795 | const char *subdir; |
| 1796 | char *buf; |
| 1797 | |
Peter Maydell | 3178320 | 2012-05-25 13:07:01 +0100 | [diff] [blame] | 1798 | /* Try the name as a straight path first */ |
| 1799 | if (access(name, R_OK) == 0) { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1800 | return g_strdup(name); |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 1801 | } |
| 1802 | switch (type) { |
| 1803 | case QEMU_FILE_TYPE_BIOS: |
| 1804 | subdir = ""; |
| 1805 | break; |
| 1806 | case QEMU_FILE_TYPE_KEYMAP: |
| 1807 | subdir = "keymaps/"; |
| 1808 | break; |
| 1809 | default: |
| 1810 | abort(); |
| 1811 | } |
| 1812 | len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1813 | buf = g_malloc0(len); |
Blue Swirl | 3a41759 | 2009-06-09 19:12:21 +0000 | [diff] [blame] | 1814 | snprintf(buf, len, "%s/%s%s", data_dir, subdir, name); |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 1815 | if (access(buf, R_OK)) { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1816 | g_free(buf); |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 1817 | return NULL; |
| 1818 | } |
| 1819 | return buf; |
| 1820 | } |
| 1821 | |
Markus Armbruster | ff952ba | 2010-01-29 19:48:57 +0100 | [diff] [blame] | 1822 | static int device_help_func(QemuOpts *opts, void *opaque) |
| 1823 | { |
| 1824 | return qdev_device_help(opts); |
| 1825 | } |
| 1826 | |
Gerd Hoffmann | f31d07d | 2009-07-31 12:25:37 +0200 | [diff] [blame] | 1827 | static int device_init_func(QemuOpts *opts, void *opaque) |
| 1828 | { |
| 1829 | DeviceState *dev; |
| 1830 | |
| 1831 | dev = qdev_device_add(opts); |
| 1832 | if (!dev) |
| 1833 | return -1; |
| 1834 | return 0; |
| 1835 | } |
| 1836 | |
Gerd Hoffmann | 1a688d3 | 2009-12-08 13:11:36 +0100 | [diff] [blame] | 1837 | static int chardev_init_func(QemuOpts *opts, void *opaque) |
| 1838 | { |
| 1839 | CharDriverState *chr; |
| 1840 | |
Anthony Liguori | f69554b | 2011-08-15 11:17:37 -0500 | [diff] [blame] | 1841 | chr = qemu_chr_new_from_opts(opts, NULL); |
Gerd Hoffmann | 1a688d3 | 2009-12-08 13:11:36 +0100 | [diff] [blame] | 1842 | if (!chr) |
| 1843 | return -1; |
| 1844 | return 0; |
| 1845 | } |
| 1846 | |
Venkateswararao Jujjuri (JV) | 758e8e3 | 2010-06-14 13:34:41 -0700 | [diff] [blame] | 1847 | #ifdef CONFIG_VIRTFS |
Gautham R Shenoy | 74db920 | 2010-04-29 17:44:43 +0530 | [diff] [blame] | 1848 | static int fsdev_init_func(QemuOpts *opts, void *opaque) |
| 1849 | { |
| 1850 | int ret; |
| 1851 | ret = qemu_fsdev_add(opts); |
| 1852 | |
| 1853 | return ret; |
| 1854 | } |
| 1855 | #endif |
| 1856 | |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1857 | static int mon_init_func(QemuOpts *opts, void *opaque) |
| 1858 | { |
| 1859 | CharDriverState *chr; |
| 1860 | const char *chardev; |
| 1861 | const char *mode; |
| 1862 | int flags; |
| 1863 | |
| 1864 | mode = qemu_opt_get(opts, "mode"); |
| 1865 | if (mode == NULL) { |
| 1866 | mode = "readline"; |
| 1867 | } |
| 1868 | if (strcmp(mode, "readline") == 0) { |
| 1869 | flags = MONITOR_USE_READLINE; |
| 1870 | } else if (strcmp(mode, "control") == 0) { |
| 1871 | flags = MONITOR_USE_CONTROL; |
| 1872 | } else { |
| 1873 | fprintf(stderr, "unknown monitor mode \"%s\"\n", mode); |
| 1874 | exit(1); |
| 1875 | } |
| 1876 | |
Daniel P. Berrange | 39eaab9 | 2010-06-07 15:42:31 +0100 | [diff] [blame] | 1877 | if (qemu_opt_get_bool(opts, "pretty", 0)) |
| 1878 | flags |= MONITOR_USE_PRETTY; |
| 1879 | |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1880 | if (qemu_opt_get_bool(opts, "default", 0)) |
| 1881 | flags |= MONITOR_IS_DEFAULT; |
| 1882 | |
| 1883 | chardev = qemu_opt_get(opts, "chardev"); |
| 1884 | chr = qemu_chr_find(chardev); |
| 1885 | if (chr == NULL) { |
| 1886 | fprintf(stderr, "chardev \"%s\" not found\n", chardev); |
| 1887 | exit(1); |
| 1888 | } |
| 1889 | |
| 1890 | monitor_init(chr, flags); |
| 1891 | return 0; |
| 1892 | } |
| 1893 | |
Gerd Hoffmann | 6ca5582 | 2009-12-08 13:11:52 +0100 | [diff] [blame] | 1894 | static void monitor_parse(const char *optarg, const char *mode) |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1895 | { |
| 1896 | static int monitor_device_index = 0; |
| 1897 | QemuOpts *opts; |
| 1898 | const char *p; |
| 1899 | char label[32]; |
| 1900 | int def = 0; |
| 1901 | |
| 1902 | if (strstart(optarg, "chardev:", &p)) { |
| 1903 | snprintf(label, sizeof(label), "%s", p); |
| 1904 | } else { |
Jan Kiszka | 140e065 | 2010-04-06 16:55:52 +0200 | [diff] [blame] | 1905 | snprintf(label, sizeof(label), "compat_monitor%d", |
| 1906 | monitor_device_index); |
| 1907 | if (monitor_device_index == 0) { |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1908 | def = 1; |
| 1909 | } |
| 1910 | opts = qemu_chr_parse_compat(label, optarg); |
| 1911 | if (!opts) { |
| 1912 | fprintf(stderr, "parse error: %s\n", optarg); |
| 1913 | exit(1); |
| 1914 | } |
| 1915 | } |
| 1916 | |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 1917 | opts = qemu_opts_create(qemu_find_opts("mon"), label, 1, NULL); |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1918 | if (!opts) { |
| 1919 | fprintf(stderr, "duplicate chardev: %s\n", label); |
| 1920 | exit(1); |
| 1921 | } |
Gerd Hoffmann | 6ca5582 | 2009-12-08 13:11:52 +0100 | [diff] [blame] | 1922 | qemu_opt_set(opts, "mode", mode); |
Gerd Hoffmann | 8858934 | 2009-12-08 13:11:50 +0100 | [diff] [blame] | 1923 | qemu_opt_set(opts, "chardev", label); |
| 1924 | if (def) |
| 1925 | qemu_opt_set(opts, "default", "on"); |
| 1926 | monitor_device_index++; |
| 1927 | } |
| 1928 | |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1929 | struct device_config { |
| 1930 | enum { |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 1931 | DEV_USB, /* -usbdevice */ |
| 1932 | DEV_BT, /* -bt */ |
| 1933 | DEV_SERIAL, /* -serial */ |
| 1934 | DEV_PARALLEL, /* -parallel */ |
| 1935 | DEV_VIRTCON, /* -virtioconsole */ |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 1936 | DEV_DEBUGCON, /* -debugcon */ |
Markus Armbruster | ef0c4a0 | 2012-02-07 15:09:13 +0100 | [diff] [blame] | 1937 | DEV_GDB, /* -gdb, -s */ |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1938 | } type; |
| 1939 | const char *cmdline; |
Markus Armbruster | d9a5954 | 2012-02-07 15:09:12 +0100 | [diff] [blame] | 1940 | Location loc; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1941 | QTAILQ_ENTRY(device_config) next; |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1942 | }; |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1943 | QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs); |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1944 | |
| 1945 | static void add_device_config(int type, const char *cmdline) |
| 1946 | { |
| 1947 | struct device_config *conf; |
| 1948 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 1949 | conf = g_malloc0(sizeof(*conf)); |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1950 | conf->type = type; |
| 1951 | conf->cmdline = cmdline; |
Markus Armbruster | d9a5954 | 2012-02-07 15:09:12 +0100 | [diff] [blame] | 1952 | loc_save(&conf->loc); |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1953 | QTAILQ_INSERT_TAIL(&device_configs, conf, next); |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1954 | } |
| 1955 | |
| 1956 | static int foreach_device_config(int type, int (*func)(const char *cmdline)) |
| 1957 | { |
| 1958 | struct device_config *conf; |
| 1959 | int rc; |
| 1960 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 1961 | QTAILQ_FOREACH(conf, &device_configs, next) { |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1962 | if (conf->type != type) |
| 1963 | continue; |
Markus Armbruster | d9a5954 | 2012-02-07 15:09:12 +0100 | [diff] [blame] | 1964 | loc_push_restore(&conf->loc); |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1965 | rc = func(conf->cmdline); |
Markus Armbruster | d9a5954 | 2012-02-07 15:09:12 +0100 | [diff] [blame] | 1966 | loc_pop(&conf->loc); |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 1967 | if (0 != rc) |
| 1968 | return rc; |
| 1969 | } |
| 1970 | return 0; |
| 1971 | } |
| 1972 | |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 1973 | static int serial_parse(const char *devname) |
| 1974 | { |
| 1975 | static int index = 0; |
| 1976 | char label[32]; |
| 1977 | |
| 1978 | if (strcmp(devname, "none") == 0) |
| 1979 | return 0; |
| 1980 | if (index == MAX_SERIAL_PORTS) { |
| 1981 | fprintf(stderr, "qemu: too many serial ports\n"); |
| 1982 | exit(1); |
| 1983 | } |
| 1984 | snprintf(label, sizeof(label), "serial%d", index); |
Anthony Liguori | 27143a4 | 2011-08-15 11:17:36 -0500 | [diff] [blame] | 1985 | serial_hds[index] = qemu_chr_new(label, devname, NULL); |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 1986 | if (!serial_hds[index]) { |
| 1987 | fprintf(stderr, "qemu: could not open serial device '%s': %s\n", |
| 1988 | devname, strerror(errno)); |
| 1989 | return -1; |
| 1990 | } |
| 1991 | index++; |
| 1992 | return 0; |
| 1993 | } |
| 1994 | |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 1995 | static int parallel_parse(const char *devname) |
| 1996 | { |
| 1997 | static int index = 0; |
| 1998 | char label[32]; |
| 1999 | |
| 2000 | if (strcmp(devname, "none") == 0) |
| 2001 | return 0; |
| 2002 | if (index == MAX_PARALLEL_PORTS) { |
| 2003 | fprintf(stderr, "qemu: too many parallel ports\n"); |
| 2004 | exit(1); |
| 2005 | } |
| 2006 | snprintf(label, sizeof(label), "parallel%d", index); |
Anthony Liguori | 27143a4 | 2011-08-15 11:17:36 -0500 | [diff] [blame] | 2007 | parallel_hds[index] = qemu_chr_new(label, devname, NULL); |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 2008 | if (!parallel_hds[index]) { |
| 2009 | fprintf(stderr, "qemu: could not open parallel device '%s': %s\n", |
| 2010 | devname, strerror(errno)); |
| 2011 | return -1; |
| 2012 | } |
| 2013 | index++; |
| 2014 | return 0; |
| 2015 | } |
| 2016 | |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2017 | static int virtcon_parse(const char *devname) |
| 2018 | { |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2019 | QemuOptsList *device = qemu_find_opts("device"); |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2020 | static int index = 0; |
| 2021 | char label[32]; |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 2022 | QemuOpts *bus_opts, *dev_opts; |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2023 | |
| 2024 | if (strcmp(devname, "none") == 0) |
| 2025 | return 0; |
| 2026 | if (index == MAX_VIRTIO_CONSOLES) { |
| 2027 | fprintf(stderr, "qemu: too many virtio consoles\n"); |
| 2028 | exit(1); |
| 2029 | } |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 2030 | |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2031 | bus_opts = qemu_opts_create(device, NULL, 0, NULL); |
Anthony Liguori | e87f7fc | 2012-02-06 11:07:18 -0600 | [diff] [blame] | 2032 | if (arch_type == QEMU_ARCH_S390X) { |
| 2033 | qemu_opt_set(bus_opts, "driver", "virtio-serial-s390"); |
| 2034 | } else { |
| 2035 | qemu_opt_set(bus_opts, "driver", "virtio-serial-pci"); |
| 2036 | } |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 2037 | |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2038 | dev_opts = qemu_opts_create(device, NULL, 0, NULL); |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 2039 | qemu_opt_set(dev_opts, "driver", "virtconsole"); |
| 2040 | |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2041 | snprintf(label, sizeof(label), "virtcon%d", index); |
Anthony Liguori | 27143a4 | 2011-08-15 11:17:36 -0500 | [diff] [blame] | 2042 | virtcon_hds[index] = qemu_chr_new(label, devname, NULL); |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2043 | if (!virtcon_hds[index]) { |
| 2044 | fprintf(stderr, "qemu: could not open virtio console '%s': %s\n", |
| 2045 | devname, strerror(errno)); |
| 2046 | return -1; |
| 2047 | } |
Amit Shah | 392ecf5 | 2010-01-21 16:19:23 +0530 | [diff] [blame] | 2048 | qemu_opt_set(dev_opts, "chardev", label); |
| 2049 | |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2050 | index++; |
| 2051 | return 0; |
| 2052 | } |
| 2053 | |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 2054 | static int debugcon_parse(const char *devname) |
| 2055 | { |
| 2056 | QemuOpts *opts; |
| 2057 | |
Anthony Liguori | 27143a4 | 2011-08-15 11:17:36 -0500 | [diff] [blame] | 2058 | if (!qemu_chr_new("debugcon", devname, NULL)) { |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 2059 | exit(1); |
| 2060 | } |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2061 | opts = qemu_opts_create(qemu_find_opts("device"), "debugcon", 1, NULL); |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 2062 | if (!opts) { |
| 2063 | fprintf(stderr, "qemu: already have a debugcon device\n"); |
| 2064 | exit(1); |
| 2065 | } |
| 2066 | qemu_opt_set(opts, "driver", "isa-debugcon"); |
| 2067 | qemu_opt_set(opts, "chardev", "debugcon"); |
| 2068 | return 0; |
| 2069 | } |
| 2070 | |
Jan Kiszka | 9052ea6 | 2011-07-23 12:38:37 +0200 | [diff] [blame] | 2071 | static QEMUMachine *machine_parse(const char *name) |
| 2072 | { |
| 2073 | QEMUMachine *m, *machine = NULL; |
| 2074 | |
| 2075 | if (name) { |
| 2076 | machine = find_machine(name); |
| 2077 | } |
| 2078 | if (machine) { |
| 2079 | return machine; |
| 2080 | } |
| 2081 | printf("Supported machines are:\n"); |
| 2082 | for (m = first_machine; m != NULL; m = m->next) { |
| 2083 | if (m->alias) { |
Peter Maydell | 3b26486 | 2012-02-22 22:13:11 +0000 | [diff] [blame] | 2084 | printf("%-20s %s (alias of %s)\n", m->alias, m->desc, m->name); |
Jan Kiszka | 9052ea6 | 2011-07-23 12:38:37 +0200 | [diff] [blame] | 2085 | } |
Peter Maydell | 3b26486 | 2012-02-22 22:13:11 +0000 | [diff] [blame] | 2086 | printf("%-20s %s%s\n", m->name, m->desc, |
Jan Kiszka | 9052ea6 | 2011-07-23 12:38:37 +0200 | [diff] [blame] | 2087 | m->is_default ? " (default)" : ""); |
| 2088 | } |
| 2089 | exit(!name || *name != '?'); |
| 2090 | } |
| 2091 | |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2092 | static int tcg_init(void) |
| 2093 | { |
Jan Kiszka | d5ab971 | 2011-08-02 16:10:21 +0200 | [diff] [blame] | 2094 | tcg_exec_init(tcg_tb_size * 1024 * 1024); |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2095 | return 0; |
| 2096 | } |
| 2097 | |
| 2098 | static struct { |
| 2099 | const char *opt_name; |
| 2100 | const char *name; |
| 2101 | int (*available)(void); |
| 2102 | int (*init)(void); |
| 2103 | int *allowed; |
| 2104 | } accel_list[] = { |
| 2105 | { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed }, |
Anthony PERARD | 3285cf4 | 2010-08-19 12:27:56 +0100 | [diff] [blame] | 2106 | { "xen", "Xen", xen_available, xen_init, &xen_allowed }, |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2107 | { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed }, |
Anthony Liguori | c7f0f3b | 2012-03-28 15:42:02 +0200 | [diff] [blame] | 2108 | { "qtest", "QTest", qtest_available, qtest_init, &qtest_allowed }, |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2109 | }; |
| 2110 | |
| 2111 | static int configure_accelerator(void) |
| 2112 | { |
| 2113 | const char *p = NULL; |
| 2114 | char buf[10]; |
| 2115 | int i, ret; |
Peter Maydell | 1b785a9 | 2012-02-07 20:57:27 +0000 | [diff] [blame] | 2116 | bool accel_initialised = 0; |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2117 | bool init_failed = 0; |
| 2118 | |
| 2119 | QemuOptsList *list = qemu_find_opts("machine"); |
| 2120 | if (!QTAILQ_EMPTY(&list->head)) { |
| 2121 | p = qemu_opt_get(QTAILQ_FIRST(&list->head), "accel"); |
| 2122 | } |
| 2123 | |
| 2124 | if (p == NULL) { |
| 2125 | /* Use the default "accelerator", tcg */ |
| 2126 | p = "tcg"; |
| 2127 | } |
| 2128 | |
Peter Maydell | 1b785a9 | 2012-02-07 20:57:27 +0000 | [diff] [blame] | 2129 | while (!accel_initialised && *p != '\0') { |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2130 | if (*p == ':') { |
| 2131 | p++; |
| 2132 | } |
| 2133 | p = get_opt_name(buf, sizeof (buf), p, ':'); |
| 2134 | for (i = 0; i < ARRAY_SIZE(accel_list); i++) { |
| 2135 | if (strcmp(accel_list[i].opt_name, buf) == 0) { |
Anthony Liguori | a16c53b | 2011-06-06 08:25:06 -0500 | [diff] [blame] | 2136 | *(accel_list[i].allowed) = 1; |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2137 | ret = accel_list[i].init(); |
| 2138 | if (ret < 0) { |
| 2139 | init_failed = 1; |
| 2140 | if (!accel_list[i].available()) { |
| 2141 | printf("%s not supported for this target\n", |
| 2142 | accel_list[i].name); |
| 2143 | } else { |
| 2144 | fprintf(stderr, "failed to initialize %s: %s\n", |
| 2145 | accel_list[i].name, |
| 2146 | strerror(-ret)); |
| 2147 | } |
Anthony Liguori | a16c53b | 2011-06-06 08:25:06 -0500 | [diff] [blame] | 2148 | *(accel_list[i].allowed) = 0; |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2149 | } else { |
Peter Maydell | 1b785a9 | 2012-02-07 20:57:27 +0000 | [diff] [blame] | 2150 | accel_initialised = 1; |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2151 | } |
| 2152 | break; |
| 2153 | } |
| 2154 | } |
| 2155 | if (i == ARRAY_SIZE(accel_list)) { |
| 2156 | fprintf(stderr, "\"%s\" accelerator does not exist.\n", buf); |
| 2157 | } |
| 2158 | } |
| 2159 | |
Peter Maydell | 1b785a9 | 2012-02-07 20:57:27 +0000 | [diff] [blame] | 2160 | if (!accel_initialised) { |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2161 | fprintf(stderr, "No accelerator found!\n"); |
| 2162 | exit(1); |
| 2163 | } |
| 2164 | |
| 2165 | if (init_failed) { |
| 2166 | fprintf(stderr, "Back to %s accelerator.\n", accel_list[i].name); |
| 2167 | } |
| 2168 | |
Peter Maydell | 1b785a9 | 2012-02-07 20:57:27 +0000 | [diff] [blame] | 2169 | return !accel_initialised; |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2170 | } |
| 2171 | |
Gerd Hoffmann | fd42dee | 2010-06-04 14:08:07 +0200 | [diff] [blame] | 2172 | void qemu_add_exit_notifier(Notifier *notify) |
| 2173 | { |
| 2174 | notifier_list_add(&exit_notifiers, notify); |
| 2175 | } |
| 2176 | |
| 2177 | void qemu_remove_exit_notifier(Notifier *notify) |
| 2178 | { |
Paolo Bonzini | 3155252 | 2012-01-13 17:34:01 +0100 | [diff] [blame] | 2179 | notifier_remove(notify); |
Gerd Hoffmann | fd42dee | 2010-06-04 14:08:07 +0200 | [diff] [blame] | 2180 | } |
| 2181 | |
| 2182 | static void qemu_run_exit_notifiers(void) |
| 2183 | { |
Jan Kiszka | 9e8dd45 | 2011-06-20 14:06:26 +0200 | [diff] [blame] | 2184 | notifier_list_notify(&exit_notifiers, NULL); |
Gerd Hoffmann | fd42dee | 2010-06-04 14:08:07 +0200 | [diff] [blame] | 2185 | } |
| 2186 | |
Gleb Natapov | 4cab946 | 2010-12-08 13:35:08 +0200 | [diff] [blame] | 2187 | void qemu_add_machine_init_done_notifier(Notifier *notify) |
| 2188 | { |
| 2189 | notifier_list_add(&machine_init_done_notifiers, notify); |
| 2190 | } |
| 2191 | |
| 2192 | static void qemu_run_machine_init_done_notifiers(void) |
| 2193 | { |
Jan Kiszka | 9e8dd45 | 2011-06-20 14:06:26 +0200 | [diff] [blame] | 2194 | notifier_list_notify(&machine_init_done_notifiers, NULL); |
Gleb Natapov | 4cab946 | 2010-12-08 13:35:08 +0200 | [diff] [blame] | 2195 | } |
| 2196 | |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2197 | static const QEMUOption *lookup_opt(int argc, char **argv, |
| 2198 | const char **poptarg, int *poptind) |
| 2199 | { |
| 2200 | const QEMUOption *popt; |
| 2201 | int optind = *poptind; |
| 2202 | char *r = argv[optind]; |
| 2203 | const char *optarg; |
| 2204 | |
Markus Armbruster | 0f0bc3f | 2010-02-18 20:13:51 +0100 | [diff] [blame] | 2205 | loc_set_cmdline(argv, optind, 1); |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2206 | optind++; |
| 2207 | /* Treat --foo the same as -foo. */ |
| 2208 | if (r[1] == '-') |
| 2209 | r++; |
| 2210 | popt = qemu_options; |
| 2211 | for(;;) { |
| 2212 | if (!popt->name) { |
Markus Armbruster | 0f0bc3f | 2010-02-18 20:13:51 +0100 | [diff] [blame] | 2213 | error_report("invalid option"); |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2214 | exit(1); |
| 2215 | } |
| 2216 | if (!strcmp(popt->name, r + 1)) |
| 2217 | break; |
| 2218 | popt++; |
| 2219 | } |
| 2220 | if (popt->flags & HAS_ARG) { |
| 2221 | if (optind >= argc) { |
Markus Armbruster | 0f0bc3f | 2010-02-18 20:13:51 +0100 | [diff] [blame] | 2222 | error_report("requires an argument"); |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2223 | exit(1); |
| 2224 | } |
| 2225 | optarg = argv[optind++]; |
Markus Armbruster | 0f0bc3f | 2010-02-18 20:13:51 +0100 | [diff] [blame] | 2226 | loc_set_cmdline(argv, optind - 2, 2); |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2227 | } else { |
| 2228 | optarg = NULL; |
| 2229 | } |
| 2230 | |
| 2231 | *poptarg = optarg; |
| 2232 | *poptind = optind; |
| 2233 | |
| 2234 | return popt; |
| 2235 | } |
| 2236 | |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2237 | static gpointer malloc_and_trace(gsize n_bytes) |
| 2238 | { |
| 2239 | void *ptr = malloc(n_bytes); |
Frediano Ziglio | a74cd8c | 2011-08-31 09:25:35 +0200 | [diff] [blame] | 2240 | trace_g_malloc(n_bytes, ptr); |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2241 | return ptr; |
| 2242 | } |
| 2243 | |
| 2244 | static gpointer realloc_and_trace(gpointer mem, gsize n_bytes) |
| 2245 | { |
| 2246 | void *ptr = realloc(mem, n_bytes); |
Frediano Ziglio | a74cd8c | 2011-08-31 09:25:35 +0200 | [diff] [blame] | 2247 | trace_g_realloc(mem, n_bytes, ptr); |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2248 | return ptr; |
| 2249 | } |
| 2250 | |
| 2251 | static void free_and_trace(gpointer mem) |
| 2252 | { |
Frediano Ziglio | a74cd8c | 2011-08-31 09:25:35 +0200 | [diff] [blame] | 2253 | trace_g_free(mem); |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2254 | free(mem); |
| 2255 | } |
| 2256 | |
Michael Roth | d34e8f6 | 2012-01-21 11:13:53 -0600 | [diff] [blame] | 2257 | int qemu_init_main_loop(void) |
| 2258 | { |
| 2259 | return main_loop_init(); |
| 2260 | } |
| 2261 | |
malc | 902b3d5 | 2008-12-10 19:18:40 +0000 | [diff] [blame] | 2262 | int main(int argc, char **argv, char **envp) |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 2263 | { |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 2264 | int i; |
Eduardo Habkost | da1fcfd | 2010-04-06 19:22:07 -0300 | [diff] [blame] | 2265 | int snapshot, linux_boot; |
Paolo Bonzini | 4e3de9e | 2010-03-10 11:38:48 +0100 | [diff] [blame] | 2266 | const char *icount_option = NULL; |
bellard | 7f7f987 | 2003-10-30 01:11:23 +0000 | [diff] [blame] | 2267 | const char *initrd_filename; |
bellard | a20dd50 | 2003-09-30 21:07:02 +0000 | [diff] [blame] | 2268 | const char *kernel_filename, *kernel_cmdline; |
Anthony Liguori | 195325a | 2009-10-30 12:42:29 -0500 | [diff] [blame] | 2269 | char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */ |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 2270 | DisplayState *ds; |
aliguori | 7d957bd | 2009-01-15 22:14:11 +0000 | [diff] [blame] | 2271 | DisplayChangeListener *dcl; |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2272 | int cyls, heads, secs, translation; |
Peter Maydell | 967c0da | 2012-02-22 22:40:00 +0000 | [diff] [blame] | 2273 | QemuOpts *hda_opts = NULL, *opts, *machine_opts; |
Gerd Hoffmann | 03b0ba7 | 2010-08-20 13:52:02 +0200 | [diff] [blame] | 2274 | QemuOptsList *olist; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2275 | int optind; |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2276 | const char *optarg; |
bellard | d63d307 | 2004-10-03 13:29:03 +0000 | [diff] [blame] | 2277 | const char *loadvm = NULL; |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 2278 | QEMUMachine *machine; |
j_mayer | 94fc95c | 2007-03-05 19:44:02 +0000 | [diff] [blame] | 2279 | const char *cpu_model; |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 2280 | const char *vga_model = "none"; |
ths | 93815bc | 2007-03-19 15:58:31 +0000 | [diff] [blame] | 2281 | const char *pid_file = NULL; |
aliguori | 5bb7910 | 2008-10-13 03:12:02 +0000 | [diff] [blame] | 2282 | const char *incoming = NULL; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 2283 | #ifdef CONFIG_VNC |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 2284 | int show_vnc_port = 0; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 2285 | #endif |
Eduardo Habkost | 3ed2d9e | 2012-05-02 13:07:28 -0300 | [diff] [blame] | 2286 | bool defconfig = true; |
Eduardo Habkost | f29a561 | 2012-05-02 13:07:29 -0300 | [diff] [blame] | 2287 | bool userconfig = true; |
Matthew Fernandez | c235d73 | 2011-06-07 16:32:40 +0000 | [diff] [blame] | 2288 | const char *log_mask = NULL; |
| 2289 | const char *log_file = NULL; |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2290 | GMemVTable mem_trace = { |
| 2291 | .malloc = malloc_and_trace, |
| 2292 | .realloc = realloc_and_trace, |
| 2293 | .free = free_and_trace, |
| 2294 | }; |
LluÃs | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 2295 | const char *trace_events = NULL; |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 2296 | const char *trace_file = NULL; |
Stefan Hajnoczi | 0b5538c | 2011-02-26 18:38:39 +0000 | [diff] [blame] | 2297 | |
Gerd Hoffmann | fd42dee | 2010-06-04 14:08:07 +0200 | [diff] [blame] | 2298 | atexit(qemu_run_exit_notifiers); |
Markus Armbruster | 65abca0 | 2010-02-24 14:37:14 +0100 | [diff] [blame] | 2299 | error_set_progname(argv[0]); |
| 2300 | |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2301 | g_mem_set_vtable(&mem_trace); |
Andreas Färber | db529aa | 2011-10-31 19:14:56 +0100 | [diff] [blame] | 2302 | if (!g_thread_supported()) { |
Alon Levy | 42ed372 | 2011-12-20 13:41:04 +0200 | [diff] [blame] | 2303 | #if !GLIB_CHECK_VERSION(2, 31, 0) |
Andreas Färber | db529aa | 2011-10-31 19:14:56 +0100 | [diff] [blame] | 2304 | g_thread_init(NULL); |
Alon Levy | 42ed372 | 2011-12-20 13:41:04 +0200 | [diff] [blame] | 2305 | #else |
| 2306 | fprintf(stderr, "glib threading failed to initialize.\n"); |
| 2307 | exit(1); |
| 2308 | #endif |
Andreas Färber | db529aa | 2011-10-31 19:14:56 +0100 | [diff] [blame] | 2309 | } |
Anthony Liguori | 0750112 | 2011-08-20 22:38:31 -0500 | [diff] [blame] | 2310 | |
Andreas Färber | 1b71f7c | 2012-03-04 21:32:35 +0100 | [diff] [blame] | 2311 | module_call_init(MODULE_INIT_QOM); |
| 2312 | |
Luiz Capitulino | 5db9d4d | 2011-09-05 16:36:31 -0300 | [diff] [blame] | 2313 | runstate_init(); |
| 2314 | |
Jan Kiszka | 6875204 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 2315 | init_clocks(); |
Paolo Bonzini | 2ff68d0 | 2011-09-12 16:21:44 +0200 | [diff] [blame] | 2316 | rtc_clock = host_clock; |
Jan Kiszka | 6875204 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 2317 | |
malc | 902b3d5 | 2008-12-10 19:18:40 +0000 | [diff] [blame] | 2318 | qemu_cache_utils_init(envp); |
| 2319 | |
Blue Swirl | 72cf2d4 | 2009-09-12 07:36:22 +0000 | [diff] [blame] | 2320 | QLIST_INIT (&vm_change_state_head); |
Jes Sorensen | fe98ac1 | 2010-06-10 11:42:21 +0200 | [diff] [blame] | 2321 | os_setup_early_signal_handling(); |
bellard | be995c2 | 2006-06-25 16:25:21 +0000 | [diff] [blame] | 2322 | |
Anthony Liguori | f80f9ec | 2009-05-20 18:38:09 -0500 | [diff] [blame] | 2323 | module_call_init(MODULE_INIT_MACHINE); |
Anthony Liguori | 0c25743 | 2009-05-21 20:41:01 -0500 | [diff] [blame] | 2324 | machine = find_default_machine(); |
j_mayer | 94fc95c | 2007-03-05 19:44:02 +0000 | [diff] [blame] | 2325 | cpu_model = NULL; |
aurel32 | 4fc5d07 | 2008-04-27 21:39:40 +0000 | [diff] [blame] | 2326 | ram_size = 0; |
bellard | 33e3963 | 2003-07-06 17:15:21 +0000 | [diff] [blame] | 2327 | snapshot = 0; |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 2328 | cyls = heads = secs = 0; |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2329 | translation = BIOS_ATA_TRANSLATION_AUTO; |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 2330 | |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 2331 | for (i = 0; i < MAX_NODES; i++) { |
| 2332 | node_mem[i] = 0; |
| 2333 | node_cpumask[i] = 0; |
| 2334 | } |
| 2335 | |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 2336 | nb_numa_nodes = 0; |
bellard | 7c9d8e0 | 2005-11-15 22:16:05 +0000 | [diff] [blame] | 2337 | nb_nics = 0; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 2338 | |
blueswir1 | 41bd639 | 2008-10-05 09:56:21 +0000 | [diff] [blame] | 2339 | autostart= 1; |
| 2340 | |
Anthony Liguori | 292444c | 2010-01-21 10:57:58 -0600 | [diff] [blame] | 2341 | /* first pass of option parsing */ |
| 2342 | optind = 1; |
| 2343 | while (optind < argc) { |
| 2344 | if (argv[optind][0] != '-') { |
| 2345 | /* disk image */ |
Anthony Liguori | 28e68d6 | 2010-01-27 10:46:00 -0600 | [diff] [blame] | 2346 | optind++; |
Anthony Liguori | 292444c | 2010-01-21 10:57:58 -0600 | [diff] [blame] | 2347 | continue; |
| 2348 | } else { |
| 2349 | const QEMUOption *popt; |
| 2350 | |
| 2351 | popt = lookup_opt(argc, argv, &optarg, &optind); |
| 2352 | switch (popt->index) { |
| 2353 | case QEMU_OPTION_nodefconfig: |
Eduardo Habkost | 3ed2d9e | 2012-05-02 13:07:28 -0300 | [diff] [blame] | 2354 | defconfig = false; |
Anthony Liguori | 292444c | 2010-01-21 10:57:58 -0600 | [diff] [blame] | 2355 | break; |
Eduardo Habkost | f29a561 | 2012-05-02 13:07:29 -0300 | [diff] [blame] | 2356 | case QEMU_OPTION_nouserconfig: |
| 2357 | userconfig = false; |
| 2358 | break; |
Anthony Liguori | 292444c | 2010-01-21 10:57:58 -0600 | [diff] [blame] | 2359 | } |
| 2360 | } |
| 2361 | } |
| 2362 | |
| 2363 | if (defconfig) { |
Kevin Wolf | dcfb093 | 2010-03-05 17:25:55 +0100 | [diff] [blame] | 2364 | int ret; |
Eduardo Habkost | f29a561 | 2012-05-02 13:07:29 -0300 | [diff] [blame] | 2365 | ret = qemu_read_default_config_files(userconfig); |
Eduardo Habkost | b5a8fe5 | 2012-05-02 13:07:25 -0300 | [diff] [blame] | 2366 | if (ret < 0) { |
Kevin Wolf | dcfb093 | 2010-03-05 17:25:55 +0100 | [diff] [blame] | 2367 | exit(1); |
Anthony Liguori | 292444c | 2010-01-21 10:57:58 -0600 | [diff] [blame] | 2368 | } |
| 2369 | } |
| 2370 | |
| 2371 | /* second pass of option parsing */ |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2372 | optind = 1; |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 2373 | for(;;) { |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2374 | if (optind >= argc) |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 2375 | break; |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2376 | if (argv[optind][0] != '-') { |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2377 | hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2378 | } else { |
| 2379 | const QEMUOption *popt; |
| 2380 | |
Anthony Liguori | 6530a97 | 2010-01-22 09:18:06 -0600 | [diff] [blame] | 2381 | popt = lookup_opt(argc, argv, &optarg, &optind); |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 2382 | if (!(popt->arch_mask & arch_type)) { |
| 2383 | printf("Option %s not supported for this target\n", popt->name); |
| 2384 | exit(1); |
| 2385 | } |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2386 | switch(popt->index) { |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 2387 | case QEMU_OPTION_M: |
Jan Kiszka | 9052ea6 | 2011-07-23 12:38:37 +0200 | [diff] [blame] | 2388 | machine = machine_parse(optarg); |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 2389 | break; |
j_mayer | 94fc95c | 2007-03-05 19:44:02 +0000 | [diff] [blame] | 2390 | case QEMU_OPTION_cpu: |
| 2391 | /* hw initialization will check this */ |
Eduardo Habkost | ecf40be | 2012-03-09 16:19:07 -0300 | [diff] [blame] | 2392 | cpu_model = optarg; |
j_mayer | 94fc95c | 2007-03-05 19:44:02 +0000 | [diff] [blame] | 2393 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2394 | case QEMU_OPTION_hda: |
Markus Armbruster | 5645b0f | 2011-01-31 11:50:09 +0100 | [diff] [blame] | 2395 | { |
| 2396 | char buf[256]; |
| 2397 | if (cyls == 0) |
| 2398 | snprintf(buf, sizeof(buf), "%s", HD_OPTS); |
| 2399 | else |
| 2400 | snprintf(buf, sizeof(buf), |
| 2401 | "%s,cyls=%d,heads=%d,secs=%d%s", |
| 2402 | HD_OPTS , cyls, heads, secs, |
| 2403 | translation == BIOS_ATA_TRANSLATION_LBA ? |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 2404 | ",trans=lba" : |
Markus Armbruster | 5645b0f | 2011-01-31 11:50:09 +0100 | [diff] [blame] | 2405 | translation == BIOS_ATA_TRANSLATION_NONE ? |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 2406 | ",trans=none" : ""); |
Markus Armbruster | 5645b0f | 2011-01-31 11:50:09 +0100 | [diff] [blame] | 2407 | drive_add(IF_DEFAULT, 0, optarg, buf); |
| 2408 | break; |
| 2409 | } |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2410 | case QEMU_OPTION_hdb: |
bellard | cc1daa4 | 2005-06-05 14:49:17 +0000 | [diff] [blame] | 2411 | case QEMU_OPTION_hdc: |
| 2412 | case QEMU_OPTION_hdd: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2413 | drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg, |
| 2414 | HD_OPTS); |
bellard | fc01f7e | 2003-06-30 10:03:06 +0000 | [diff] [blame] | 2415 | break; |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 2416 | case QEMU_OPTION_drive: |
Michael Tokarev | e2982c3 | 2011-03-30 16:31:05 +0400 | [diff] [blame] | 2417 | if (drive_def(optarg) == NULL) { |
| 2418 | exit(1); |
| 2419 | } |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 2420 | break; |
Gerd Hoffmann | d058fe0 | 2009-07-31 12:25:36 +0200 | [diff] [blame] | 2421 | case QEMU_OPTION_set: |
| 2422 | if (qemu_set_option(optarg) != 0) |
| 2423 | exit(1); |
| 2424 | break; |
Gerd Hoffmann | d0fef6f | 2009-12-08 13:11:34 +0100 | [diff] [blame] | 2425 | case QEMU_OPTION_global: |
| 2426 | if (qemu_global_option(optarg) != 0) |
| 2427 | exit(1); |
| 2428 | break; |
balrog | 3e3d581 | 2007-04-30 02:09:25 +0000 | [diff] [blame] | 2429 | case QEMU_OPTION_mtdblock: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2430 | drive_add(IF_MTD, -1, optarg, MTD_OPTS); |
balrog | 3e3d581 | 2007-04-30 02:09:25 +0000 | [diff] [blame] | 2431 | break; |
pbrook | a1bb27b | 2007-04-06 16:49:48 +0000 | [diff] [blame] | 2432 | case QEMU_OPTION_sd: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2433 | drive_add(IF_SD, 0, optarg, SD_OPTS); |
pbrook | a1bb27b | 2007-04-06 16:49:48 +0000 | [diff] [blame] | 2434 | break; |
j_mayer | 86f5566 | 2007-04-24 06:52:59 +0000 | [diff] [blame] | 2435 | case QEMU_OPTION_pflash: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2436 | drive_add(IF_PFLASH, -1, optarg, PFLASH_OPTS); |
j_mayer | 86f5566 | 2007-04-24 06:52:59 +0000 | [diff] [blame] | 2437 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2438 | case QEMU_OPTION_snapshot: |
bellard | 33e3963 | 2003-07-06 17:15:21 +0000 | [diff] [blame] | 2439 | snapshot = 1; |
| 2440 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2441 | case QEMU_OPTION_hdachs: |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 2442 | { |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 2443 | const char *p; |
| 2444 | p = optarg; |
| 2445 | cyls = strtol(p, (char **)&p, 0); |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2446 | if (cyls < 1 || cyls > 16383) |
| 2447 | goto chs_fail; |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 2448 | if (*p != ',') |
| 2449 | goto chs_fail; |
| 2450 | p++; |
| 2451 | heads = strtol(p, (char **)&p, 0); |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2452 | if (heads < 1 || heads > 16) |
| 2453 | goto chs_fail; |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 2454 | if (*p != ',') |
| 2455 | goto chs_fail; |
| 2456 | p++; |
| 2457 | secs = strtol(p, (char **)&p, 0); |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2458 | if (secs < 1 || secs > 63) |
| 2459 | goto chs_fail; |
| 2460 | if (*p == ',') { |
| 2461 | p++; |
| 2462 | if (!strcmp(p, "none")) |
| 2463 | translation = BIOS_ATA_TRANSLATION_NONE; |
| 2464 | else if (!strcmp(p, "lba")) |
| 2465 | translation = BIOS_ATA_TRANSLATION_LBA; |
| 2466 | else if (!strcmp(p, "auto")) |
| 2467 | translation = BIOS_ATA_TRANSLATION_AUTO; |
| 2468 | else |
| 2469 | goto chs_fail; |
| 2470 | } else if (*p != '\0') { |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 2471 | chs_fail: |
bellard | 46d4767 | 2004-11-16 01:45:27 +0000 | [diff] [blame] | 2472 | fprintf(stderr, "qemu: invalid physical CHS format\n"); |
| 2473 | exit(1); |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 2474 | } |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 2475 | if (hda_opts != NULL) { |
| 2476 | char num[16]; |
| 2477 | snprintf(num, sizeof(num), "%d", cyls); |
| 2478 | qemu_opt_set(hda_opts, "cyls", num); |
| 2479 | snprintf(num, sizeof(num), "%d", heads); |
| 2480 | qemu_opt_set(hda_opts, "heads", num); |
| 2481 | snprintf(num, sizeof(num), "%d", secs); |
| 2482 | qemu_opt_set(hda_opts, "secs", num); |
| 2483 | if (translation == BIOS_ATA_TRANSLATION_LBA) |
| 2484 | qemu_opt_set(hda_opts, "trans", "lba"); |
| 2485 | if (translation == BIOS_ATA_TRANSLATION_NONE) |
| 2486 | qemu_opt_set(hda_opts, "trans", "none"); |
| 2487 | } |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 2488 | } |
| 2489 | break; |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 2490 | case QEMU_OPTION_numa: |
| 2491 | if (nb_numa_nodes >= MAX_NODES) { |
| 2492 | fprintf(stderr, "qemu: too many NUMA nodes\n"); |
| 2493 | exit(1); |
| 2494 | } |
| 2495 | numa_add(optarg); |
| 2496 | break; |
Jes Sorensen | 1472a95 | 2011-03-16 13:33:31 +0100 | [diff] [blame] | 2497 | case QEMU_OPTION_display: |
| 2498 | display_type = select_display(optarg); |
| 2499 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2500 | case QEMU_OPTION_nographic: |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 2501 | display_type = DT_NOGRAPHIC; |
bellard | a20dd50 | 2003-09-30 21:07:02 +0000 | [diff] [blame] | 2502 | break; |
balrog | 4d3b6f6 | 2008-02-10 16:33:14 +0000 | [diff] [blame] | 2503 | case QEMU_OPTION_curses: |
Jes Sorensen | 47b0536 | 2011-03-16 13:33:35 +0100 | [diff] [blame] | 2504 | #ifdef CONFIG_CURSES |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 2505 | display_type = DT_CURSES; |
Jes Sorensen | 47b0536 | 2011-03-16 13:33:35 +0100 | [diff] [blame] | 2506 | #else |
| 2507 | fprintf(stderr, "Curses support is disabled\n"); |
| 2508 | exit(1); |
balrog | 4d3b6f6 | 2008-02-10 16:33:14 +0000 | [diff] [blame] | 2509 | #endif |
Jes Sorensen | 47b0536 | 2011-03-16 13:33:35 +0100 | [diff] [blame] | 2510 | break; |
balrog | a171fe3 | 2007-04-30 01:48:07 +0000 | [diff] [blame] | 2511 | case QEMU_OPTION_portrait: |
Vasily Khoruzhick | 9312805 | 2011-06-17 13:04:36 +0300 | [diff] [blame] | 2512 | graphic_rotate = 90; |
| 2513 | break; |
| 2514 | case QEMU_OPTION_rotate: |
| 2515 | graphic_rotate = strtol(optarg, (char **) &optarg, 10); |
| 2516 | if (graphic_rotate != 0 && graphic_rotate != 90 && |
| 2517 | graphic_rotate != 180 && graphic_rotate != 270) { |
| 2518 | fprintf(stderr, |
| 2519 | "qemu: only 90, 180, 270 deg rotation is available\n"); |
| 2520 | exit(1); |
| 2521 | } |
balrog | a171fe3 | 2007-04-30 01:48:07 +0000 | [diff] [blame] | 2522 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2523 | case QEMU_OPTION_kernel: |
Peter Maydell | a0abe47 | 2012-02-08 05:41:39 +0000 | [diff] [blame] | 2524 | qemu_opts_set(qemu_find_opts("machine"), 0, "kernel", optarg); |
| 2525 | break; |
| 2526 | case QEMU_OPTION_initrd: |
| 2527 | qemu_opts_set(qemu_find_opts("machine"), 0, "initrd", optarg); |
bellard | a20dd50 | 2003-09-30 21:07:02 +0000 | [diff] [blame] | 2528 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2529 | case QEMU_OPTION_append: |
Peter Maydell | a0abe47 | 2012-02-08 05:41:39 +0000 | [diff] [blame] | 2530 | qemu_opts_set(qemu_find_opts("machine"), 0, "append", optarg); |
bellard | 313aa56 | 2003-08-10 21:52:11 +0000 | [diff] [blame] | 2531 | break; |
Grant Likely | 412beee | 2012-03-02 11:56:38 +0000 | [diff] [blame] | 2532 | case QEMU_OPTION_dtb: |
| 2533 | qemu_opts_set(qemu_find_opts("machine"), 0, "dtb", optarg); |
| 2534 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2535 | case QEMU_OPTION_cdrom: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2536 | drive_add(IF_DEFAULT, 2, optarg, CDROM_OPTS); |
bellard | 36b486b | 2003-11-11 13:36:08 +0000 | [diff] [blame] | 2537 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2538 | case QEMU_OPTION_boot: |
j_mayer | 28c5af5 | 2007-11-11 01:50:45 +0000 | [diff] [blame] | 2539 | { |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2540 | static const char * const params[] = { |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 2541 | "order", "once", "menu", |
| 2542 | "splash", "splash-time", NULL |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2543 | }; |
| 2544 | char buf[sizeof(boot_devices)]; |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2545 | char *standard_boot_devices; |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2546 | int legacy = 0; |
| 2547 | |
| 2548 | if (!strchr(optarg, '=')) { |
| 2549 | legacy = 1; |
| 2550 | pstrcpy(buf, sizeof(buf), optarg); |
| 2551 | } else if (check_params(buf, sizeof(buf), params, optarg) < 0) { |
| 2552 | fprintf(stderr, |
| 2553 | "qemu: unknown boot parameter '%s' in '%s'\n", |
| 2554 | buf, optarg); |
| 2555 | exit(1); |
| 2556 | } |
| 2557 | |
| 2558 | if (legacy || |
| 2559 | get_param_value(buf, sizeof(buf), "order", optarg)) { |
Eduardo Habkost | 4e9e9d6 | 2010-04-06 19:22:08 -0300 | [diff] [blame] | 2560 | validate_bootdevices(buf); |
Jan Kiszka | ef3adf6 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2561 | pstrcpy(boot_devices, sizeof(boot_devices), buf); |
j_mayer | 28c5af5 | 2007-11-11 01:50:45 +0000 | [diff] [blame] | 2562 | } |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2563 | if (!legacy) { |
| 2564 | if (get_param_value(buf, sizeof(buf), |
| 2565 | "once", optarg)) { |
Eduardo Habkost | 4e9e9d6 | 2010-04-06 19:22:08 -0300 | [diff] [blame] | 2566 | validate_bootdevices(buf); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 2567 | standard_boot_devices = g_strdup(boot_devices); |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2568 | pstrcpy(boot_devices, sizeof(boot_devices), buf); |
| 2569 | qemu_register_reset(restore_boot_devices, |
| 2570 | standard_boot_devices); |
| 2571 | } |
Jan Kiszka | 9538749 | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2572 | if (get_param_value(buf, sizeof(buf), |
| 2573 | "menu", optarg)) { |
| 2574 | if (!strcmp(buf, "on")) { |
| 2575 | boot_menu = 1; |
| 2576 | } else if (!strcmp(buf, "off")) { |
| 2577 | boot_menu = 0; |
| 2578 | } else { |
| 2579 | fprintf(stderr, |
| 2580 | "qemu: invalid option value '%s'\n", |
| 2581 | buf); |
| 2582 | exit(1); |
| 2583 | } |
| 2584 | } |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 2585 | qemu_opts_parse(qemu_find_opts("boot-opts"), |
| 2586 | optarg, 0); |
Jan Kiszka | e0f084b | 2009-07-02 00:19:02 +0200 | [diff] [blame] | 2587 | } |
bellard | 36b486b | 2003-11-11 13:36:08 +0000 | [diff] [blame] | 2588 | } |
| 2589 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2590 | case QEMU_OPTION_fda: |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2591 | case QEMU_OPTION_fdb: |
Markus Armbruster | 2292dda | 2011-01-28 11:21:41 +0100 | [diff] [blame] | 2592 | drive_add(IF_FLOPPY, popt->index - QEMU_OPTION_fda, |
| 2593 | optarg, FD_OPTS); |
bellard | c45886d | 2004-01-05 00:02:06 +0000 | [diff] [blame] | 2594 | break; |
bellard | 52ca8d6 | 2006-06-14 16:03:05 +0000 | [diff] [blame] | 2595 | case QEMU_OPTION_no_fd_bootchk: |
| 2596 | fd_bootchk = 0; |
| 2597 | break; |
Mark McLoughlin | a1ea458 | 2009-10-08 19:58:26 +0100 | [diff] [blame] | 2598 | case QEMU_OPTION_netdev: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2599 | if (net_client_parse(qemu_find_opts("netdev"), optarg) == -1) { |
Mark McLoughlin | a1ea458 | 2009-10-08 19:58:26 +0100 | [diff] [blame] | 2600 | exit(1); |
| 2601 | } |
| 2602 | break; |
bellard | 7c9d8e0 | 2005-11-15 22:16:05 +0000 | [diff] [blame] | 2603 | case QEMU_OPTION_net: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2604 | if (net_client_parse(qemu_find_opts("net"), optarg) == -1) { |
bellard | c4b1fcc | 2004-03-14 21:44:30 +0000 | [diff] [blame] | 2605 | exit(1); |
| 2606 | } |
bellard | 702c651 | 2004-04-02 21:21:32 +0000 | [diff] [blame] | 2607 | break; |
Ronnie Sahlberg | f9dadc9 | 2012-01-26 09:39:02 +1100 | [diff] [blame] | 2608 | #ifdef CONFIG_LIBISCSI |
| 2609 | case QEMU_OPTION_iscsi: |
| 2610 | opts = qemu_opts_parse(qemu_find_opts("iscsi"), optarg, 0); |
| 2611 | if (!opts) { |
| 2612 | exit(1); |
| 2613 | } |
| 2614 | break; |
| 2615 | #endif |
bellard | c7f7464 | 2004-08-24 21:57:12 +0000 | [diff] [blame] | 2616 | #ifdef CONFIG_SLIRP |
| 2617 | case QEMU_OPTION_tftp: |
Jan Kiszka | ad196a9 | 2009-06-24 14:42:28 +0200 | [diff] [blame] | 2618 | legacy_tftp_prefix = optarg; |
bellard | 9bf0544 | 2004-08-25 22:12:49 +0000 | [diff] [blame] | 2619 | break; |
ths | 47d5d01 | 2007-02-20 00:05:08 +0000 | [diff] [blame] | 2620 | case QEMU_OPTION_bootp: |
Jan Kiszka | ad196a9 | 2009-06-24 14:42:28 +0200 | [diff] [blame] | 2621 | legacy_bootp_filename = optarg; |
ths | 47d5d01 | 2007-02-20 00:05:08 +0000 | [diff] [blame] | 2622 | break; |
bellard | 9bf0544 | 2004-08-25 22:12:49 +0000 | [diff] [blame] | 2623 | case QEMU_OPTION_redir: |
Markus Armbruster | 0752706 | 2009-10-06 12:16:57 +0100 | [diff] [blame] | 2624 | if (net_slirp_redir(optarg) < 0) |
| 2625 | exit(1); |
bellard | 9bf0544 | 2004-08-25 22:12:49 +0000 | [diff] [blame] | 2626 | break; |
bellard | c7f7464 | 2004-08-24 21:57:12 +0000 | [diff] [blame] | 2627 | #endif |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 2628 | case QEMU_OPTION_bt: |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 2629 | add_device_config(DEV_BT, optarg); |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 2630 | break; |
bellard | 1d14ffa | 2005-10-30 18:58:22 +0000 | [diff] [blame] | 2631 | case QEMU_OPTION_audio_help: |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 2632 | if (!(audio_available())) { |
| 2633 | printf("Option %s not supported for this target\n", popt->name); |
| 2634 | exit(1); |
| 2635 | } |
bellard | 1d14ffa | 2005-10-30 18:58:22 +0000 | [diff] [blame] | 2636 | AUD_help (); |
| 2637 | exit (0); |
| 2638 | break; |
| 2639 | case QEMU_OPTION_soundhw: |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 2640 | if (!(audio_available())) { |
| 2641 | printf("Option %s not supported for this target\n", popt->name); |
| 2642 | exit(1); |
| 2643 | } |
bellard | 1d14ffa | 2005-10-30 18:58:22 +0000 | [diff] [blame] | 2644 | select_soundhw (optarg); |
| 2645 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2646 | case QEMU_OPTION_h: |
ths | 15f8220 | 2007-06-29 23:26:08 +0000 | [diff] [blame] | 2647 | help(0); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2648 | break; |
pbrook | 9bd7e6d | 2009-04-07 22:58:45 +0000 | [diff] [blame] | 2649 | case QEMU_OPTION_version: |
| 2650 | version(); |
| 2651 | exit(0); |
| 2652 | break; |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2653 | case QEMU_OPTION_m: { |
Jes Sorensen | 70b4f4b | 2011-01-05 11:41:02 +0100 | [diff] [blame] | 2654 | int64_t value; |
Markus Armbruster | 961b42b | 2011-11-22 09:46:03 +0100 | [diff] [blame] | 2655 | char *end; |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2656 | |
Markus Armbruster | 961b42b | 2011-11-22 09:46:03 +0100 | [diff] [blame] | 2657 | value = strtosz(optarg, &end); |
| 2658 | if (value < 0 || *end) { |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2659 | fprintf(stderr, "qemu: invalid ram size: %s\n", optarg); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2660 | exit(1); |
| 2661 | } |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2662 | |
Anthony Liguori | c227f09 | 2009-10-01 16:12:16 -0500 | [diff] [blame] | 2663 | if (value != (uint64_t)(ram_addr_t)value) { |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2664 | fprintf(stderr, "qemu: ram size too large\n"); |
| 2665 | exit(1); |
| 2666 | } |
| 2667 | ram_size = value; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2668 | break; |
aurel32 | 00f82b8 | 2008-04-27 21:12:55 +0000 | [diff] [blame] | 2669 | } |
Marcelo Tosatti | c902760 | 2010-03-01 20:25:08 -0300 | [diff] [blame] | 2670 | case QEMU_OPTION_mempath: |
| 2671 | mem_path = optarg; |
| 2672 | break; |
| 2673 | #ifdef MAP_POPULATE |
| 2674 | case QEMU_OPTION_mem_prealloc: |
| 2675 | mem_prealloc = 1; |
| 2676 | break; |
| 2677 | #endif |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2678 | case QEMU_OPTION_d: |
Matthew Fernandez | c235d73 | 2011-06-07 16:32:40 +0000 | [diff] [blame] | 2679 | log_mask = optarg; |
| 2680 | break; |
| 2681 | case QEMU_OPTION_D: |
| 2682 | log_file = optarg; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2683 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2684 | case QEMU_OPTION_s: |
Markus Armbruster | ef0c4a0 | 2012-02-07 15:09:13 +0100 | [diff] [blame] | 2685 | add_device_config(DEV_GDB, "tcp::" DEFAULT_GDBSTUB_PORT); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2686 | break; |
aliguori | 59030a8 | 2009-04-05 18:43:41 +0000 | [diff] [blame] | 2687 | case QEMU_OPTION_gdb: |
Markus Armbruster | ef0c4a0 | 2012-02-07 15:09:13 +0100 | [diff] [blame] | 2688 | add_device_config(DEV_GDB, optarg); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2689 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2690 | case QEMU_OPTION_L: |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 2691 | data_dir = optarg; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2692 | break; |
j_mayer | 1192dad | 2007-10-05 13:08:35 +0000 | [diff] [blame] | 2693 | case QEMU_OPTION_bios: |
| 2694 | bios_name = optarg; |
| 2695 | break; |
aurel32 | 1b530a6 | 2009-04-05 20:08:59 +0000 | [diff] [blame] | 2696 | case QEMU_OPTION_singlestep: |
| 2697 | singlestep = 1; |
| 2698 | break; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2699 | case QEMU_OPTION_S: |
pbrook | 3c07f8e | 2007-01-21 16:47:01 +0000 | [diff] [blame] | 2700 | autostart = 0; |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 2701 | break; |
bellard | 3d11d0e | 2004-12-12 16:56:30 +0000 | [diff] [blame] | 2702 | case QEMU_OPTION_k: |
| 2703 | keyboard_layout = optarg; |
| 2704 | break; |
bellard | ee22c2f | 2004-06-03 12:49:50 +0000 | [diff] [blame] | 2705 | case QEMU_OPTION_localtime: |
| 2706 | rtc_utc = 0; |
| 2707 | break; |
malc | 3893c12 | 2008-09-28 00:42:05 +0000 | [diff] [blame] | 2708 | case QEMU_OPTION_vga: |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 2709 | vga_model = optarg; |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 2710 | default_vga = 0; |
bellard | 1bfe856 | 2004-07-08 21:17:50 +0000 | [diff] [blame] | 2711 | break; |
bellard | e9b137c | 2004-06-21 16:46:10 +0000 | [diff] [blame] | 2712 | case QEMU_OPTION_g: |
| 2713 | { |
| 2714 | const char *p; |
| 2715 | int w, h, depth; |
| 2716 | p = optarg; |
| 2717 | w = strtol(p, (char **)&p, 10); |
| 2718 | if (w <= 0) { |
| 2719 | graphic_error: |
| 2720 | fprintf(stderr, "qemu: invalid resolution or depth\n"); |
| 2721 | exit(1); |
| 2722 | } |
| 2723 | if (*p != 'x') |
| 2724 | goto graphic_error; |
| 2725 | p++; |
| 2726 | h = strtol(p, (char **)&p, 10); |
| 2727 | if (h <= 0) |
| 2728 | goto graphic_error; |
| 2729 | if (*p == 'x') { |
| 2730 | p++; |
| 2731 | depth = strtol(p, (char **)&p, 10); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 2732 | if (depth != 8 && depth != 15 && depth != 16 && |
bellard | e9b137c | 2004-06-21 16:46:10 +0000 | [diff] [blame] | 2733 | depth != 24 && depth != 32) |
| 2734 | goto graphic_error; |
| 2735 | } else if (*p == '\0') { |
| 2736 | depth = graphic_depth; |
| 2737 | } else { |
| 2738 | goto graphic_error; |
| 2739 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 2740 | |
bellard | e9b137c | 2004-06-21 16:46:10 +0000 | [diff] [blame] | 2741 | graphic_width = w; |
| 2742 | graphic_height = h; |
| 2743 | graphic_depth = depth; |
| 2744 | } |
| 2745 | break; |
ths | 20d8a3e | 2007-02-18 17:04:49 +0000 | [diff] [blame] | 2746 | case QEMU_OPTION_echr: |
| 2747 | { |
| 2748 | char *r; |
| 2749 | term_escape_char = strtol(optarg, &r, 0); |
| 2750 | if (r == optarg) |
| 2751 | printf("Bad argument to echr\n"); |
| 2752 | break; |
| 2753 | } |
bellard | 82c643f | 2004-07-14 17:28:13 +0000 | [diff] [blame] | 2754 | case QEMU_OPTION_monitor: |
Gerd Hoffmann | 6ca5582 | 2009-12-08 13:11:52 +0100 | [diff] [blame] | 2755 | monitor_parse(optarg, "readline"); |
| 2756 | default_monitor = 0; |
| 2757 | break; |
| 2758 | case QEMU_OPTION_qmp: |
| 2759 | monitor_parse(optarg, "control"); |
Anthony Liguori | 2d114dc | 2010-03-21 14:14:38 -0500 | [diff] [blame] | 2760 | default_monitor = 0; |
bellard | 82c643f | 2004-07-14 17:28:13 +0000 | [diff] [blame] | 2761 | break; |
Gerd Hoffmann | 22a0e04 | 2009-12-08 13:11:51 +0100 | [diff] [blame] | 2762 | case QEMU_OPTION_mon: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2763 | opts = qemu_opts_parse(qemu_find_opts("mon"), optarg, 1); |
Gerd Hoffmann | 22a0e04 | 2009-12-08 13:11:51 +0100 | [diff] [blame] | 2764 | if (!opts) { |
Gerd Hoffmann | 22a0e04 | 2009-12-08 13:11:51 +0100 | [diff] [blame] | 2765 | exit(1); |
| 2766 | } |
Anthony Liguori | 2d114dc | 2010-03-21 14:14:38 -0500 | [diff] [blame] | 2767 | default_monitor = 0; |
Gerd Hoffmann | 22a0e04 | 2009-12-08 13:11:51 +0100 | [diff] [blame] | 2768 | break; |
Gerd Hoffmann | 191bc01 | 2009-09-10 10:58:35 +0200 | [diff] [blame] | 2769 | case QEMU_OPTION_chardev: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2770 | opts = qemu_opts_parse(qemu_find_opts("chardev"), optarg, 1); |
Gerd Hoffmann | 191bc01 | 2009-09-10 10:58:35 +0200 | [diff] [blame] | 2771 | if (!opts) { |
Gerd Hoffmann | 191bc01 | 2009-09-10 10:58:35 +0200 | [diff] [blame] | 2772 | exit(1); |
| 2773 | } |
Gerd Hoffmann | 191bc01 | 2009-09-10 10:58:35 +0200 | [diff] [blame] | 2774 | break; |
Gautham R Shenoy | 74db920 | 2010-04-29 17:44:43 +0530 | [diff] [blame] | 2775 | case QEMU_OPTION_fsdev: |
Gerd Hoffmann | 03b0ba7 | 2010-08-20 13:52:02 +0200 | [diff] [blame] | 2776 | olist = qemu_find_opts("fsdev"); |
| 2777 | if (!olist) { |
| 2778 | fprintf(stderr, "fsdev is not supported by this qemu build.\n"); |
| 2779 | exit(1); |
| 2780 | } |
| 2781 | opts = qemu_opts_parse(olist, optarg, 1); |
Gautham R Shenoy | 74db920 | 2010-04-29 17:44:43 +0530 | [diff] [blame] | 2782 | if (!opts) { |
| 2783 | fprintf(stderr, "parse error: %s\n", optarg); |
| 2784 | exit(1); |
| 2785 | } |
| 2786 | break; |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2787 | case QEMU_OPTION_virtfs: { |
Stefan Hajnoczi | e14ea47 | 2011-03-16 08:31:43 +0000 | [diff] [blame] | 2788 | QemuOpts *fsdev; |
| 2789 | QemuOpts *device; |
M. Mohan Kumar | 84a87cc | 2011-12-14 13:58:47 +0530 | [diff] [blame] | 2790 | const char *writeout, *sock_fd, *socket; |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2791 | |
Gerd Hoffmann | 03b0ba7 | 2010-08-20 13:52:02 +0200 | [diff] [blame] | 2792 | olist = qemu_find_opts("virtfs"); |
| 2793 | if (!olist) { |
| 2794 | fprintf(stderr, "virtfs is not supported by this qemu build.\n"); |
| 2795 | exit(1); |
| 2796 | } |
| 2797 | opts = qemu_opts_parse(olist, optarg, 1); |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2798 | if (!opts) { |
| 2799 | fprintf(stderr, "parse error: %s\n", optarg); |
| 2800 | exit(1); |
| 2801 | } |
| 2802 | |
Aneesh Kumar K.V | fbcbf10 | 2011-10-13 12:28:04 +0530 | [diff] [blame] | 2803 | if (qemu_opt_get(opts, "fsdriver") == NULL || |
Aneesh Kumar K.V | 99519f0 | 2011-12-14 13:48:59 +0530 | [diff] [blame] | 2804 | qemu_opt_get(opts, "mount_tag") == NULL) { |
| 2805 | fprintf(stderr, "Usage: -virtfs fsdriver,mount_tag=tag.\n"); |
Venkateswararao Jujjuri (JV) | 9ce56db | 2010-06-14 13:34:40 -0700 | [diff] [blame] | 2806 | exit(1); |
| 2807 | } |
Stefan Hajnoczi | e14ea47 | 2011-03-16 08:31:43 +0000 | [diff] [blame] | 2808 | fsdev = qemu_opts_create(qemu_find_opts("fsdev"), |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2809 | qemu_opt_get(opts, "mount_tag"), |
| 2810 | 1, NULL); |
Stefan Hajnoczi | e14ea47 | 2011-03-16 08:31:43 +0000 | [diff] [blame] | 2811 | if (!fsdev) { |
| 2812 | fprintf(stderr, "duplicate fsdev id: %s\n", |
| 2813 | qemu_opt_get(opts, "mount_tag")); |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2814 | exit(1); |
| 2815 | } |
Aneesh Kumar K.V | d3ab98e | 2011-10-12 19:11:23 +0530 | [diff] [blame] | 2816 | |
| 2817 | writeout = qemu_opt_get(opts, "writeout"); |
| 2818 | if (writeout) { |
| 2819 | #ifdef CONFIG_SYNC_FILE_RANGE |
| 2820 | qemu_opt_set(fsdev, "writeout", writeout); |
| 2821 | #else |
| 2822 | fprintf(stderr, "writeout=immediate not supported on " |
| 2823 | "this platform\n"); |
| 2824 | exit(1); |
| 2825 | #endif |
| 2826 | } |
Aneesh Kumar K.V | fbcbf10 | 2011-10-13 12:28:04 +0530 | [diff] [blame] | 2827 | qemu_opt_set(fsdev, "fsdriver", qemu_opt_get(opts, "fsdriver")); |
Stefan Hajnoczi | e14ea47 | 2011-03-16 08:31:43 +0000 | [diff] [blame] | 2828 | qemu_opt_set(fsdev, "path", qemu_opt_get(opts, "path")); |
| 2829 | qemu_opt_set(fsdev, "security_model", |
| 2830 | qemu_opt_get(opts, "security_model")); |
M. Mohan Kumar | 84a87cc | 2011-12-14 13:58:47 +0530 | [diff] [blame] | 2831 | socket = qemu_opt_get(opts, "socket"); |
| 2832 | if (socket) { |
| 2833 | qemu_opt_set(fsdev, "socket", socket); |
| 2834 | } |
M. Mohan Kumar | 4c793dd | 2011-12-14 13:49:28 +0530 | [diff] [blame] | 2835 | sock_fd = qemu_opt_get(opts, "sock_fd"); |
| 2836 | if (sock_fd) { |
| 2837 | qemu_opt_set(fsdev, "sock_fd", sock_fd); |
| 2838 | } |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2839 | |
M. Mohan Kumar | 2c74c2c | 2011-10-25 12:10:39 +0530 | [diff] [blame] | 2840 | qemu_opt_set_bool(fsdev, "readonly", |
| 2841 | qemu_opt_get_bool(opts, "readonly", 0)); |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2842 | device = qemu_opts_create(qemu_find_opts("device"), NULL, 0, |
| 2843 | NULL); |
Stefan Hajnoczi | e14ea47 | 2011-03-16 08:31:43 +0000 | [diff] [blame] | 2844 | qemu_opt_set(device, "driver", "virtio-9p-pci"); |
| 2845 | qemu_opt_set(device, "fsdev", |
| 2846 | qemu_opt_get(opts, "mount_tag")); |
| 2847 | qemu_opt_set(device, "mount_tag", |
| 2848 | qemu_opt_get(opts, "mount_tag")); |
Gautham R Shenoy | 3d54abc | 2010-04-29 17:45:03 +0530 | [diff] [blame] | 2849 | break; |
| 2850 | } |
Aneesh Kumar K.V | 9db221a | 2011-10-25 12:10:40 +0530 | [diff] [blame] | 2851 | case QEMU_OPTION_virtfs_synth: { |
| 2852 | QemuOpts *fsdev; |
| 2853 | QemuOpts *device; |
| 2854 | |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2855 | fsdev = qemu_opts_create(qemu_find_opts("fsdev"), "v_synth", |
| 2856 | 1, NULL); |
Aneesh Kumar K.V | 9db221a | 2011-10-25 12:10:40 +0530 | [diff] [blame] | 2857 | if (!fsdev) { |
| 2858 | fprintf(stderr, "duplicate option: %s\n", "virtfs_synth"); |
| 2859 | exit(1); |
| 2860 | } |
| 2861 | qemu_opt_set(fsdev, "fsdriver", "synth"); |
Aneesh Kumar K.V | 9db221a | 2011-10-25 12:10:40 +0530 | [diff] [blame] | 2862 | |
Luiz Capitulino | 8be7e7e | 2012-03-20 15:51:57 -0300 | [diff] [blame] | 2863 | device = qemu_opts_create(qemu_find_opts("device"), NULL, 0, |
| 2864 | NULL); |
Aneesh Kumar K.V | 9db221a | 2011-10-25 12:10:40 +0530 | [diff] [blame] | 2865 | qemu_opt_set(device, "driver", "virtio-9p-pci"); |
| 2866 | qemu_opt_set(device, "fsdev", "v_synth"); |
| 2867 | qemu_opt_set(device, "mount_tag", "v_synth"); |
| 2868 | break; |
| 2869 | } |
bellard | 82c643f | 2004-07-14 17:28:13 +0000 | [diff] [blame] | 2870 | case QEMU_OPTION_serial: |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 2871 | add_device_config(DEV_SERIAL, optarg); |
| 2872 | default_serial = 0; |
Jan Kiszka | 18141ed | 2010-03-07 11:28:40 +0100 | [diff] [blame] | 2873 | if (strncmp(optarg, "mon:", 4) == 0) { |
| 2874 | default_monitor = 0; |
| 2875 | } |
bellard | 82c643f | 2004-07-14 17:28:13 +0000 | [diff] [blame] | 2876 | break; |
Richard W.M. Jones | 9dd986c | 2009-04-25 13:56:19 +0100 | [diff] [blame] | 2877 | case QEMU_OPTION_watchdog: |
Markus Armbruster | 09aaa16 | 2009-08-21 10:31:34 +0200 | [diff] [blame] | 2878 | if (watchdog) { |
| 2879 | fprintf(stderr, |
| 2880 | "qemu: only one watchdog option may be given\n"); |
| 2881 | return 1; |
| 2882 | } |
| 2883 | watchdog = optarg; |
Richard W.M. Jones | 9dd986c | 2009-04-25 13:56:19 +0100 | [diff] [blame] | 2884 | break; |
| 2885 | case QEMU_OPTION_watchdog_action: |
| 2886 | if (select_watchdog_action(optarg) == -1) { |
| 2887 | fprintf(stderr, "Unknown -watchdog-action parameter\n"); |
| 2888 | exit(1); |
| 2889 | } |
| 2890 | break; |
aliguori | 51ecf13 | 2009-01-15 20:06:40 +0000 | [diff] [blame] | 2891 | case QEMU_OPTION_virtiocon: |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 2892 | add_device_config(DEV_VIRTCON, optarg); |
| 2893 | default_virtcon = 0; |
Jan Kiszka | 18141ed | 2010-03-07 11:28:40 +0100 | [diff] [blame] | 2894 | if (strncmp(optarg, "mon:", 4) == 0) { |
| 2895 | default_monitor = 0; |
| 2896 | } |
aliguori | 51ecf13 | 2009-01-15 20:06:40 +0000 | [diff] [blame] | 2897 | break; |
bellard | 6508fe5 | 2005-01-15 12:02:56 +0000 | [diff] [blame] | 2898 | case QEMU_OPTION_parallel: |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 2899 | add_device_config(DEV_PARALLEL, optarg); |
| 2900 | default_parallel = 0; |
Jan Kiszka | 18141ed | 2010-03-07 11:28:40 +0100 | [diff] [blame] | 2901 | if (strncmp(optarg, "mon:", 4) == 0) { |
| 2902 | default_monitor = 0; |
| 2903 | } |
bellard | 6508fe5 | 2005-01-15 12:02:56 +0000 | [diff] [blame] | 2904 | break; |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 2905 | case QEMU_OPTION_debugcon: |
| 2906 | add_device_config(DEV_DEBUGCON, optarg); |
| 2907 | break; |
bellard | d63d307 | 2004-10-03 13:29:03 +0000 | [diff] [blame] | 2908 | case QEMU_OPTION_loadvm: |
| 2909 | loadvm = optarg; |
| 2910 | break; |
| 2911 | case QEMU_OPTION_full_screen: |
| 2912 | full_screen = 1; |
| 2913 | break; |
ths | 667acca | 2006-12-11 02:08:05 +0000 | [diff] [blame] | 2914 | #ifdef CONFIG_SDL |
ths | 43523e9 | 2007-02-18 18:19:32 +0000 | [diff] [blame] | 2915 | case QEMU_OPTION_no_frame: |
| 2916 | no_frame = 1; |
| 2917 | break; |
ths | 3780e19 | 2007-06-21 21:08:02 +0000 | [diff] [blame] | 2918 | case QEMU_OPTION_alt_grab: |
| 2919 | alt_grab = 1; |
| 2920 | break; |
Dustin Kirkland | 0ca9f8a | 2009-09-17 15:48:04 -0500 | [diff] [blame] | 2921 | case QEMU_OPTION_ctrl_grab: |
| 2922 | ctrl_grab = 1; |
| 2923 | break; |
ths | 667acca | 2006-12-11 02:08:05 +0000 | [diff] [blame] | 2924 | case QEMU_OPTION_no_quit: |
| 2925 | no_quit = 1; |
| 2926 | break; |
aliguori | 7d957bd | 2009-01-15 22:14:11 +0000 | [diff] [blame] | 2927 | case QEMU_OPTION_sdl: |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 2928 | display_type = DT_SDL; |
aliguori | 7d957bd | 2009-01-15 22:14:11 +0000 | [diff] [blame] | 2929 | break; |
Jes Sorensen | 58fc096 | 2011-03-16 13:33:34 +0100 | [diff] [blame] | 2930 | #else |
| 2931 | case QEMU_OPTION_no_frame: |
| 2932 | case QEMU_OPTION_alt_grab: |
| 2933 | case QEMU_OPTION_ctrl_grab: |
| 2934 | case QEMU_OPTION_no_quit: |
| 2935 | case QEMU_OPTION_sdl: |
| 2936 | fprintf(stderr, "SDL support is disabled\n"); |
| 2937 | exit(1); |
ths | 667acca | 2006-12-11 02:08:05 +0000 | [diff] [blame] | 2938 | #endif |
bellard | f7cce89 | 2004-12-08 22:21:25 +0000 | [diff] [blame] | 2939 | case QEMU_OPTION_pidfile: |
ths | 93815bc | 2007-03-19 15:58:31 +0000 | [diff] [blame] | 2940 | pid_file = optarg; |
bellard | f7cce89 | 2004-12-08 22:21:25 +0000 | [diff] [blame] | 2941 | break; |
bellard | a09db21 | 2005-04-30 16:10:35 +0000 | [diff] [blame] | 2942 | case QEMU_OPTION_win2k_hack: |
| 2943 | win2k_install_hack = 1; |
| 2944 | break; |
Jan Kiszka | 433acf0 | 2012-01-23 20:15:12 +0100 | [diff] [blame] | 2945 | case QEMU_OPTION_rtc_td_hack: { |
| 2946 | static GlobalProperty slew_lost_ticks[] = { |
| 2947 | { |
| 2948 | .driver = "mc146818rtc", |
| 2949 | .property = "lost_tick_policy", |
| 2950 | .value = "slew", |
| 2951 | }, |
| 2952 | { /* end of list */ } |
| 2953 | }; |
| 2954 | |
| 2955 | qdev_prop_register_global_list(slew_lost_ticks); |
aliguori | 73822ec | 2009-01-15 20:11:34 +0000 | [diff] [blame] | 2956 | break; |
Jan Kiszka | 433acf0 | 2012-01-23 20:15:12 +0100 | [diff] [blame] | 2957 | } |
aliguori | 8a92ea2 | 2009-02-27 20:12:36 +0000 | [diff] [blame] | 2958 | case QEMU_OPTION_acpitable: |
Blue Swirl | de06f8d | 2010-03-29 19:23:50 +0000 | [diff] [blame] | 2959 | do_acpitable_option(optarg); |
aliguori | 8a92ea2 | 2009-02-27 20:12:36 +0000 | [diff] [blame] | 2960 | break; |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 2961 | case QEMU_OPTION_smbios: |
Blue Swirl | de06f8d | 2010-03-29 19:23:50 +0000 | [diff] [blame] | 2962 | do_smbios_option(optarg); |
aliguori | b6f6e3d | 2009-04-17 18:59:56 +0000 | [diff] [blame] | 2963 | break; |
aliguori | 7ba1e61 | 2008-11-05 16:04:33 +0000 | [diff] [blame] | 2964 | case QEMU_OPTION_enable_kvm: |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2965 | olist = qemu_find_opts("machine"); |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2966 | qemu_opts_parse(olist, "accel=kvm", 0); |
| 2967 | break; |
| 2968 | case QEMU_OPTION_machine: |
| 2969 | olist = qemu_find_opts("machine"); |
Jan Kiszka | 9052ea6 | 2011-07-23 12:38:37 +0200 | [diff] [blame] | 2970 | opts = qemu_opts_parse(olist, optarg, 1); |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 2971 | if (!opts) { |
| 2972 | fprintf(stderr, "parse error: %s\n", optarg); |
| 2973 | exit(1); |
| 2974 | } |
Jan Kiszka | 2645c6d | 2011-07-25 18:11:20 +0200 | [diff] [blame] | 2975 | optarg = qemu_opt_get(opts, "type"); |
| 2976 | if (optarg) { |
| 2977 | machine = machine_parse(optarg); |
| 2978 | } |
aliguori | 7ba1e61 | 2008-11-05 16:04:33 +0000 | [diff] [blame] | 2979 | break; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 2980 | case QEMU_OPTION_usb: |
| 2981 | usb_enabled = 1; |
| 2982 | break; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 2983 | case QEMU_OPTION_usbdevice: |
| 2984 | usb_enabled = 1; |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 2985 | add_device_config(DEV_USB, optarg); |
| 2986 | break; |
| 2987 | case QEMU_OPTION_device: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 2988 | if (!qemu_opts_parse(qemu_find_opts("device"), optarg, 1)) { |
Gerd Hoffmann | f31d07d | 2009-07-31 12:25:37 +0200 | [diff] [blame] | 2989 | exit(1); |
| 2990 | } |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 2991 | break; |
bellard | 6a00d60 | 2005-11-21 23:25:50 +0000 | [diff] [blame] | 2992 | case QEMU_OPTION_smp: |
Andre Przywara | dc6b1c0 | 2009-08-19 15:42:40 +0200 | [diff] [blame] | 2993 | smp_parse(optarg); |
aliguori | b209700 | 2008-10-07 20:39:39 +0000 | [diff] [blame] | 2994 | if (smp_cpus < 1) { |
bellard | 6a00d60 | 2005-11-21 23:25:50 +0000 | [diff] [blame] | 2995 | fprintf(stderr, "Invalid number of CPUs\n"); |
| 2996 | exit(1); |
| 2997 | } |
Jes Sorensen | 6be68d7 | 2009-07-23 17:03:42 +0200 | [diff] [blame] | 2998 | if (max_cpus < smp_cpus) { |
| 2999 | fprintf(stderr, "maxcpus must be equal to or greater than " |
| 3000 | "smp\n"); |
| 3001 | exit(1); |
| 3002 | } |
| 3003 | if (max_cpus > 255) { |
| 3004 | fprintf(stderr, "Unsupported number of maxcpus\n"); |
| 3005 | exit(1); |
| 3006 | } |
bellard | 6a00d60 | 2005-11-21 23:25:50 +0000 | [diff] [blame] | 3007 | break; |
bellard | 2423686 | 2006-04-30 21:28:36 +0000 | [diff] [blame] | 3008 | case QEMU_OPTION_vnc: |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3009 | #ifdef CONFIG_VNC |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3010 | display_remote++; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3011 | vnc_display = optarg; |
| 3012 | #else |
| 3013 | fprintf(stderr, "VNC support is disabled\n"); |
| 3014 | exit(1); |
| 3015 | #endif |
| 3016 | break; |
bellard | 6515b20 | 2006-05-03 22:02:44 +0000 | [diff] [blame] | 3017 | case QEMU_OPTION_no_acpi: |
| 3018 | acpi_enabled = 0; |
| 3019 | break; |
aliguori | 16b29ae | 2008-12-17 23:28:44 +0000 | [diff] [blame] | 3020 | case QEMU_OPTION_no_hpet: |
| 3021 | no_hpet = 1; |
| 3022 | break; |
Markus Armbruster | 7d4c3d5 | 2009-06-26 19:15:14 +0200 | [diff] [blame] | 3023 | case QEMU_OPTION_balloon: |
| 3024 | if (balloon_parse(optarg) < 0) { |
| 3025 | fprintf(stderr, "Unknown -balloon argument %s\n", optarg); |
| 3026 | exit(1); |
| 3027 | } |
Eduardo Habkost | df97b92 | 2009-06-10 16:34:08 -0300 | [diff] [blame] | 3028 | break; |
bellard | d1beab8 | 2006-10-02 19:44:22 +0000 | [diff] [blame] | 3029 | case QEMU_OPTION_no_reboot: |
| 3030 | no_reboot = 1; |
| 3031 | break; |
aurel32 | b2f7616 | 2008-04-11 21:35:52 +0000 | [diff] [blame] | 3032 | case QEMU_OPTION_no_shutdown: |
| 3033 | no_shutdown = 1; |
| 3034 | break; |
balrog | 9467cd4 | 2007-05-01 01:34:14 +0000 | [diff] [blame] | 3035 | case QEMU_OPTION_show_cursor: |
| 3036 | cursor_hide = 0; |
| 3037 | break; |
blueswir1 | 8fcb1b9 | 2008-09-18 18:29:08 +0000 | [diff] [blame] | 3038 | case QEMU_OPTION_uuid: |
| 3039 | if(qemu_uuid_parse(optarg, qemu_uuid) < 0) { |
| 3040 | fprintf(stderr, "Fail to parse UUID string." |
| 3041 | " Wrong format.\n"); |
| 3042 | exit(1); |
| 3043 | } |
| 3044 | break; |
ths | 9ae0255 | 2007-01-05 17:39:04 +0000 | [diff] [blame] | 3045 | case QEMU_OPTION_option_rom: |
| 3046 | if (nb_option_roms >= MAX_OPTION_ROMS) { |
| 3047 | fprintf(stderr, "Too many option ROMs\n"); |
| 3048 | exit(1); |
| 3049 | } |
Gleb Natapov | 2e55e84 | 2010-12-08 13:35:07 +0200 | [diff] [blame] | 3050 | opts = qemu_opts_parse(qemu_find_opts("option-rom"), optarg, 1); |
| 3051 | option_rom[nb_option_roms].name = qemu_opt_get(opts, "romfile"); |
| 3052 | option_rom[nb_option_roms].bootindex = |
| 3053 | qemu_opt_get_number(opts, "bootindex", -1); |
| 3054 | if (!option_rom[nb_option_roms].name) { |
| 3055 | fprintf(stderr, "Option ROM file is not specified\n"); |
| 3056 | exit(1); |
| 3057 | } |
ths | 9ae0255 | 2007-01-05 17:39:04 +0000 | [diff] [blame] | 3058 | nb_option_roms++; |
| 3059 | break; |
pbrook | 8e71621 | 2007-01-20 17:12:09 +0000 | [diff] [blame] | 3060 | case QEMU_OPTION_semihosting: |
| 3061 | semihosting_enabled = 1; |
| 3062 | break; |
ths | c35734b | 2007-03-19 15:17:08 +0000 | [diff] [blame] | 3063 | case QEMU_OPTION_name: |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 3064 | qemu_name = g_strdup(optarg); |
Andi Kleen | 1889465 | 2009-07-02 09:34:17 +0200 | [diff] [blame] | 3065 | { |
| 3066 | char *p = strchr(qemu_name, ','); |
| 3067 | if (p != NULL) { |
| 3068 | *p++ = 0; |
| 3069 | if (strncmp(p, "process=", 8)) { |
Aurelien Jarno | 5697f6a | 2010-12-27 18:29:20 +0100 | [diff] [blame] | 3070 | fprintf(stderr, "Unknown subargument %s to -name\n", p); |
Andi Kleen | 1889465 | 2009-07-02 09:34:17 +0200 | [diff] [blame] | 3071 | exit(1); |
| 3072 | } |
| 3073 | p += 8; |
Jes Sorensen | ce798cf | 2010-06-10 11:42:31 +0200 | [diff] [blame] | 3074 | os_set_proc_name(p); |
Andi Kleen | 1889465 | 2009-07-02 09:34:17 +0200 | [diff] [blame] | 3075 | } |
| 3076 | } |
ths | c35734b | 2007-03-19 15:17:08 +0000 | [diff] [blame] | 3077 | break; |
blueswir1 | 6650860 | 2007-05-01 14:16:52 +0000 | [diff] [blame] | 3078 | case QEMU_OPTION_prom_env: |
| 3079 | if (nb_prom_envs >= MAX_PROM_ENVS) { |
| 3080 | fprintf(stderr, "Too many prom variables\n"); |
| 3081 | exit(1); |
| 3082 | } |
| 3083 | prom_envs[nb_prom_envs] = optarg; |
| 3084 | nb_prom_envs++; |
| 3085 | break; |
balrog | 2b8f2d4 | 2007-07-27 22:08:46 +0000 | [diff] [blame] | 3086 | case QEMU_OPTION_old_param: |
| 3087 | old_param = 1; |
ths | 05ebd53 | 2008-01-08 19:32:16 +0000 | [diff] [blame] | 3088 | break; |
ths | f3dcfad | 2007-08-24 01:26:02 +0000 | [diff] [blame] | 3089 | case QEMU_OPTION_clock: |
| 3090 | configure_alarms(optarg); |
| 3091 | break; |
bellard | 7e0af5d0 | 2007-11-07 16:24:33 +0000 | [diff] [blame] | 3092 | case QEMU_OPTION_startdate: |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 3093 | configure_rtc_date_offset(optarg, 1); |
| 3094 | break; |
| 3095 | case QEMU_OPTION_rtc: |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3096 | opts = qemu_opts_parse(qemu_find_opts("rtc"), optarg, 0); |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 3097 | if (!opts) { |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 3098 | exit(1); |
bellard | 7e0af5d0 | 2007-11-07 16:24:33 +0000 | [diff] [blame] | 3099 | } |
Jan Kiszka | 1ed2fc1 | 2009-09-15 13:36:04 +0200 | [diff] [blame] | 3100 | configure_rtc(opts); |
bellard | 7e0af5d0 | 2007-11-07 16:24:33 +0000 | [diff] [blame] | 3101 | break; |
bellard | 26a5f13 | 2008-05-28 12:30:31 +0000 | [diff] [blame] | 3102 | case QEMU_OPTION_tb_size: |
Jan Kiszka | d5ab971 | 2011-08-02 16:10:21 +0200 | [diff] [blame] | 3103 | tcg_tb_size = strtol(optarg, NULL, 0); |
| 3104 | if (tcg_tb_size < 0) { |
| 3105 | tcg_tb_size = 0; |
| 3106 | } |
bellard | 26a5f13 | 2008-05-28 12:30:31 +0000 | [diff] [blame] | 3107 | break; |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 3108 | case QEMU_OPTION_icount: |
Paolo Bonzini | 4e3de9e | 2010-03-10 11:38:48 +0100 | [diff] [blame] | 3109 | icount_option = optarg; |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 3110 | break; |
aliguori | 5bb7910 | 2008-10-13 03:12:02 +0000 | [diff] [blame] | 3111 | case QEMU_OPTION_incoming: |
| 3112 | incoming = optarg; |
Stefano Stabellini | 81323a6 | 2012-01-18 12:23:13 +0000 | [diff] [blame] | 3113 | runstate_set(RUN_STATE_INMIGRATE); |
aliguori | 5bb7910 | 2008-10-13 03:12:02 +0000 | [diff] [blame] | 3114 | break; |
Gerd Hoffmann | d8c208d | 2009-12-08 13:11:46 +0100 | [diff] [blame] | 3115 | case QEMU_OPTION_nodefaults: |
| 3116 | default_serial = 0; |
| 3117 | default_parallel = 0; |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 3118 | default_virtcon = 0; |
Gerd Hoffmann | d8c208d | 2009-12-08 13:11:46 +0100 | [diff] [blame] | 3119 | default_monitor = 0; |
Gerd Hoffmann | cb4522c | 2009-12-08 13:11:47 +0100 | [diff] [blame] | 3120 | default_net = 0; |
Gerd Hoffmann | ac33f8f | 2009-12-16 14:25:39 +0100 | [diff] [blame] | 3121 | default_floppy = 0; |
| 3122 | default_cdrom = 0; |
| 3123 | default_sdcard = 0; |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 3124 | default_vga = 0; |
Gerd Hoffmann | d8c208d | 2009-12-08 13:11:46 +0100 | [diff] [blame] | 3125 | break; |
aliguori | e37630c | 2009-04-22 15:19:10 +0000 | [diff] [blame] | 3126 | case QEMU_OPTION_xen_domid: |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 3127 | if (!(xen_available())) { |
| 3128 | printf("Option %s not supported for this target\n", popt->name); |
| 3129 | exit(1); |
| 3130 | } |
aliguori | e37630c | 2009-04-22 15:19:10 +0000 | [diff] [blame] | 3131 | xen_domid = atoi(optarg); |
| 3132 | break; |
| 3133 | case QEMU_OPTION_xen_create: |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 3134 | if (!(xen_available())) { |
| 3135 | printf("Option %s not supported for this target\n", popt->name); |
| 3136 | exit(1); |
| 3137 | } |
aliguori | e37630c | 2009-04-22 15:19:10 +0000 | [diff] [blame] | 3138 | xen_mode = XEN_CREATE; |
| 3139 | break; |
| 3140 | case QEMU_OPTION_xen_attach: |
Blue Swirl | ad96090 | 2010-03-29 19:23:52 +0000 | [diff] [blame] | 3141 | if (!(xen_available())) { |
| 3142 | printf("Option %s not supported for this target\n", popt->name); |
| 3143 | exit(1); |
| 3144 | } |
aliguori | e37630c | 2009-04-22 15:19:10 +0000 | [diff] [blame] | 3145 | xen_mode = XEN_ATTACH; |
| 3146 | break; |
Prerna Saxena | ab6540d | 2010-08-09 11:48:32 +0100 | [diff] [blame] | 3147 | case QEMU_OPTION_trace: |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 3148 | { |
Prerna Saxena | ab6540d | 2010-08-09 11:48:32 +0100 | [diff] [blame] | 3149 | opts = qemu_opts_parse(qemu_find_opts("trace"), optarg, 0); |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 3150 | if (!opts) { |
| 3151 | exit(1); |
Prerna Saxena | ab6540d | 2010-08-09 11:48:32 +0100 | [diff] [blame] | 3152 | } |
LluÃs | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 3153 | trace_events = qemu_opt_get(opts, "events"); |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 3154 | trace_file = qemu_opt_get(opts, "file"); |
Prerna Saxena | ab6540d | 2010-08-09 11:48:32 +0100 | [diff] [blame] | 3155 | break; |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 3156 | } |
Gerd Hoffmann | 715a664 | 2009-10-14 10:39:28 +0200 | [diff] [blame] | 3157 | case QEMU_OPTION_readconfig: |
| 3158 | { |
Kevin Wolf | dcfb093 | 2010-03-05 17:25:55 +0100 | [diff] [blame] | 3159 | int ret = qemu_read_config_file(optarg); |
| 3160 | if (ret < 0) { |
| 3161 | fprintf(stderr, "read config %s: %s\n", optarg, |
| 3162 | strerror(-ret)); |
Gerd Hoffmann | 715a664 | 2009-10-14 10:39:28 +0200 | [diff] [blame] | 3163 | exit(1); |
| 3164 | } |
Gerd Hoffmann | 715a664 | 2009-10-14 10:39:28 +0200 | [diff] [blame] | 3165 | break; |
| 3166 | } |
Gerd Hoffmann | 29b0040 | 2010-03-11 11:13:27 -0300 | [diff] [blame] | 3167 | case QEMU_OPTION_spice: |
| 3168 | olist = qemu_find_opts("spice"); |
| 3169 | if (!olist) { |
| 3170 | fprintf(stderr, "spice is not supported by this qemu build.\n"); |
| 3171 | exit(1); |
| 3172 | } |
| 3173 | opts = qemu_opts_parse(olist, optarg, 0); |
| 3174 | if (!opts) { |
| 3175 | fprintf(stderr, "parse error: %s\n", optarg); |
| 3176 | exit(1); |
| 3177 | } |
| 3178 | break; |
Gerd Hoffmann | 715a664 | 2009-10-14 10:39:28 +0200 | [diff] [blame] | 3179 | case QEMU_OPTION_writeconfig: |
| 3180 | { |
| 3181 | FILE *fp; |
| 3182 | if (strcmp(optarg, "-") == 0) { |
| 3183 | fp = stdout; |
| 3184 | } else { |
| 3185 | fp = fopen(optarg, "w"); |
| 3186 | if (fp == NULL) { |
| 3187 | fprintf(stderr, "open %s: %s\n", optarg, strerror(errno)); |
| 3188 | exit(1); |
| 3189 | } |
| 3190 | } |
| 3191 | qemu_config_write(fp); |
| 3192 | fclose(fp); |
| 3193 | break; |
| 3194 | } |
Anthony Liguori | c7f0f3b | 2012-03-28 15:42:02 +0200 | [diff] [blame] | 3195 | case QEMU_OPTION_qtest: |
| 3196 | qtest_chrdev = optarg; |
| 3197 | break; |
| 3198 | case QEMU_OPTION_qtest_log: |
| 3199 | qtest_log = optarg; |
| 3200 | break; |
Jes Sorensen | 59a5264 | 2010-06-10 11:42:25 +0200 | [diff] [blame] | 3201 | default: |
| 3202 | os_parse_cmd_args(popt->index, optarg); |
bellard | cd6f116 | 2004-05-13 22:02:20 +0000 | [diff] [blame] | 3203 | } |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 3204 | } |
| 3205 | } |
Markus Armbruster | 0f0bc3f | 2010-02-18 20:13:51 +0100 | [diff] [blame] | 3206 | loc_set_none(); |
bellard | 330d041 | 2003-07-26 18:11:40 +0000 | [diff] [blame] | 3207 | |
CrÃstian Viana | 93bfef4 | 2012-05-30 00:35:51 -0300 | [diff] [blame] | 3208 | if (machine->hw_version) { |
| 3209 | qemu_set_version(machine->hw_version); |
| 3210 | } |
| 3211 | |
Eduardo Habkost | ecf40be | 2012-03-09 16:19:07 -0300 | [diff] [blame] | 3212 | /* Init CPU def lists, based on config |
| 3213 | * - Must be called after all the qemu_read_config_file() calls |
| 3214 | * - Must be called before list_cpus() |
| 3215 | * - Must be called before machine->init() |
| 3216 | */ |
| 3217 | cpudef_init(); |
| 3218 | |
| 3219 | if (cpu_model && *cpu_model == '?') { |
Eduardo Habkost | 1d6528a | 2012-03-21 09:33:40 -0300 | [diff] [blame] | 3220 | list_cpus(stdout, &fprintf, cpu_model); |
Eduardo Habkost | ecf40be | 2012-03-09 16:19:07 -0300 | [diff] [blame] | 3221 | exit(0); |
| 3222 | } |
| 3223 | |
Matthew Fernandez | c235d73 | 2011-06-07 16:32:40 +0000 | [diff] [blame] | 3224 | /* Open the logfile at this point, if necessary. We can't open the logfile |
| 3225 | * when encountering either of the logging options (-d or -D) because the |
| 3226 | * other one may be encountered later on the command line, changing the |
| 3227 | * location or level of logging. |
| 3228 | */ |
| 3229 | if (log_mask) { |
| 3230 | if (log_file) { |
| 3231 | set_cpu_log_filename(log_file); |
| 3232 | } |
| 3233 | set_cpu_log(log_mask); |
| 3234 | } |
| 3235 | |
LluÃs | 23d15e8 | 2011-08-31 20:31:31 +0200 | [diff] [blame] | 3236 | if (!trace_backend_init(trace_events, trace_file)) { |
LluÃs | e485897 | 2011-08-31 20:31:03 +0200 | [diff] [blame] | 3237 | exit(1); |
Stefan Hajnoczi | 31d3c9b | 2011-03-13 20:14:30 +0000 | [diff] [blame] | 3238 | } |
Stefan Hajnoczi | 0b5538c | 2011-02-26 18:38:39 +0000 | [diff] [blame] | 3239 | |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 3240 | /* If no data_dir is specified then try to find it relative to the |
| 3241 | executable path. */ |
| 3242 | if (!data_dir) { |
Jes Sorensen | 6170540 | 2010-06-10 11:42:23 +0200 | [diff] [blame] | 3243 | data_dir = os_find_datadir(argv[0]); |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 3244 | } |
Stefan Weil | 60474fb | 2011-09-04 15:17:46 +0200 | [diff] [blame] | 3245 | /* If all else fails use the install path specified when building. */ |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 3246 | if (!data_dir) { |
Paolo Bonzini | 1dabe05 | 2010-05-26 16:08:25 +0200 | [diff] [blame] | 3247 | data_dir = CONFIG_QEMU_DATADIR; |
Paul Brook | 5cea859 | 2009-05-30 00:52:44 +0100 | [diff] [blame] | 3248 | } |
| 3249 | |
Andreas Färber | d423675 | 2011-11-10 16:35:32 +0100 | [diff] [blame] | 3250 | if (machine == NULL) { |
| 3251 | fprintf(stderr, "No machine found.\n"); |
| 3252 | exit(1); |
| 3253 | } |
| 3254 | |
Jes Sorensen | 6be68d7 | 2009-07-23 17:03:42 +0200 | [diff] [blame] | 3255 | /* |
| 3256 | * Default to max_cpus = smp_cpus, in case the user doesn't |
| 3257 | * specify a max_cpus value. |
| 3258 | */ |
| 3259 | if (!max_cpus) |
| 3260 | max_cpus = smp_cpus; |
| 3261 | |
balrog | 3d878ca | 2008-10-28 10:59:59 +0000 | [diff] [blame] | 3262 | machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */ |
aliguori | b209700 | 2008-10-07 20:39:39 +0000 | [diff] [blame] | 3263 | if (smp_cpus > machine->max_cpus) { |
| 3264 | fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus " |
| 3265 | "supported by machine `%s' (%d)\n", smp_cpus, machine->name, |
| 3266 | machine->max_cpus); |
| 3267 | exit(1); |
| 3268 | } |
| 3269 | |
Anthony PERARD | 67b724e | 2010-11-22 15:44:15 +0000 | [diff] [blame] | 3270 | /* |
| 3271 | * Get the default machine options from the machine if it is not already |
| 3272 | * specified either by the configuration file or by the command line. |
| 3273 | */ |
| 3274 | if (machine->default_machine_opts) { |
Jan Kiszka | 25de593 | 2012-01-27 19:55:43 +0100 | [diff] [blame] | 3275 | qemu_opts_set_defaults(qemu_find_opts("machine"), |
| 3276 | machine->default_machine_opts, 0); |
Anthony PERARD | 67b724e | 2010-11-22 15:44:15 +0000 | [diff] [blame] | 3277 | } |
| 3278 | |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3279 | qemu_opts_foreach(qemu_find_opts("device"), default_driver_check, NULL, 0); |
| 3280 | qemu_opts_foreach(qemu_find_opts("global"), default_driver_check, NULL, 0); |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 3281 | |
Gerd Hoffmann | 986c5f7 | 2009-12-08 13:11:54 +0100 | [diff] [blame] | 3282 | if (machine->no_serial) { |
| 3283 | default_serial = 0; |
| 3284 | } |
| 3285 | if (machine->no_parallel) { |
| 3286 | default_parallel = 0; |
| 3287 | } |
| 3288 | if (!machine->use_virtcon) { |
| 3289 | default_virtcon = 0; |
| 3290 | } |
Gerd Hoffmann | ac33f8f | 2009-12-16 14:25:39 +0100 | [diff] [blame] | 3291 | if (machine->no_floppy) { |
| 3292 | default_floppy = 0; |
| 3293 | } |
| 3294 | if (machine->no_cdrom) { |
| 3295 | default_cdrom = 0; |
| 3296 | } |
| 3297 | if (machine->no_sdcard) { |
| 3298 | default_sdcard = 0; |
| 3299 | } |
Gerd Hoffmann | 986c5f7 | 2009-12-08 13:11:54 +0100 | [diff] [blame] | 3300 | |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3301 | if (display_type == DT_NOGRAPHIC) { |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 3302 | if (default_parallel) |
| 3303 | add_device_config(DEV_PARALLEL, "null"); |
Gerd Hoffmann | e1c0917 | 2009-12-08 13:11:44 +0100 | [diff] [blame] | 3304 | if (default_serial && default_monitor) { |
| 3305 | add_device_config(DEV_SERIAL, "mon:stdio"); |
Gerd Hoffmann | 986c5f7 | 2009-12-08 13:11:54 +0100 | [diff] [blame] | 3306 | } else if (default_virtcon && default_monitor) { |
| 3307 | add_device_config(DEV_VIRTCON, "mon:stdio"); |
Gerd Hoffmann | e1c0917 | 2009-12-08 13:11:44 +0100 | [diff] [blame] | 3308 | } else { |
| 3309 | if (default_serial) |
| 3310 | add_device_config(DEV_SERIAL, "stdio"); |
Gerd Hoffmann | 986c5f7 | 2009-12-08 13:11:54 +0100 | [diff] [blame] | 3311 | if (default_virtcon) |
| 3312 | add_device_config(DEV_VIRTCON, "stdio"); |
Gerd Hoffmann | e1c0917 | 2009-12-08 13:11:44 +0100 | [diff] [blame] | 3313 | if (default_monitor) |
Gerd Hoffmann | 6ca5582 | 2009-12-08 13:11:52 +0100 | [diff] [blame] | 3314 | monitor_parse("stdio", "readline"); |
Gerd Hoffmann | e1c0917 | 2009-12-08 13:11:44 +0100 | [diff] [blame] | 3315 | } |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 3316 | } else { |
| 3317 | if (default_serial) |
| 3318 | add_device_config(DEV_SERIAL, "vc:80Cx24C"); |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 3319 | if (default_parallel) |
| 3320 | add_device_config(DEV_PARALLEL, "vc:80Cx24C"); |
Gerd Hoffmann | abdeed0 | 2009-12-08 13:11:43 +0100 | [diff] [blame] | 3321 | if (default_monitor) |
Gerd Hoffmann | 6ca5582 | 2009-12-08 13:11:52 +0100 | [diff] [blame] | 3322 | monitor_parse("vc:80Cx24C", "readline"); |
Alexander Graf | 38536da | 2009-12-17 13:06:08 +0100 | [diff] [blame] | 3323 | if (default_virtcon) |
| 3324 | add_device_config(DEV_VIRTCON, "vc:80Cx24C"); |
aliguori | bc0129d | 2008-08-01 15:12:34 +0000 | [diff] [blame] | 3325 | } |
| 3326 | |
TeLeMan | a5829fd | 2010-04-15 12:37:55 +0800 | [diff] [blame] | 3327 | socket_init(); |
| 3328 | |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3329 | if (qemu_opts_foreach(qemu_find_opts("chardev"), chardev_init_func, NULL, 1) != 0) |
Gerd Hoffmann | 1a688d3 | 2009-12-08 13:11:36 +0100 | [diff] [blame] | 3330 | exit(1); |
Venkateswararao Jujjuri (JV) | 758e8e3 | 2010-06-14 13:34:41 -0700 | [diff] [blame] | 3331 | #ifdef CONFIG_VIRTFS |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3332 | if (qemu_opts_foreach(qemu_find_opts("fsdev"), fsdev_init_func, NULL, 1) != 0) { |
Gautham R Shenoy | 74db920 | 2010-04-29 17:44:43 +0530 | [diff] [blame] | 3333 | exit(1); |
| 3334 | } |
| 3335 | #endif |
Gerd Hoffmann | 1a688d3 | 2009-12-08 13:11:36 +0100 | [diff] [blame] | 3336 | |
Jes Sorensen | eb505be | 2010-06-10 11:42:28 +0200 | [diff] [blame] | 3337 | os_daemonize(); |
ths | 71e3ceb | 2006-12-22 02:11:31 +0000 | [diff] [blame] | 3338 | |
ths | aa26bb2 | 2007-03-25 21:33:06 +0000 | [diff] [blame] | 3339 | if (pid_file && qemu_create_pidfile(pid_file) != 0) { |
Jes Sorensen | eb505be | 2010-06-10 11:42:28 +0200 | [diff] [blame] | 3340 | os_pidfile_error(); |
ths | 93815bc | 2007-03-19 15:58:31 +0000 | [diff] [blame] | 3341 | exit(1); |
| 3342 | } |
| 3343 | |
Jan Kiszka | 0ac543d | 2011-08-15 16:18:57 -0700 | [diff] [blame] | 3344 | /* init the memory */ |
| 3345 | if (ram_size == 0) { |
| 3346 | ram_size = DEFAULT_RAM_SIZE * 1024 * 1024; |
| 3347 | } |
| 3348 | |
Anthony PERARD | 303d4e8 | 2010-09-21 20:05:31 +0100 | [diff] [blame] | 3349 | configure_accelerator(); |
Marcelo Tosatti | 214910a | 2009-09-18 02:41:23 -0300 | [diff] [blame] | 3350 | |
Paolo Bonzini | d3b12f5 | 2011-09-13 10:30:52 +0200 | [diff] [blame] | 3351 | qemu_init_cpu_loop(); |
aliguori | 3fcf7b6 | 2009-04-24 18:03:25 +0000 | [diff] [blame] | 3352 | if (qemu_init_main_loop()) { |
| 3353 | fprintf(stderr, "qemu_init_main_loop failed\n"); |
| 3354 | exit(1); |
| 3355 | } |
Peter Maydell | a0abe47 | 2012-02-08 05:41:39 +0000 | [diff] [blame] | 3356 | |
Peter Maydell | 967c0da | 2012-02-22 22:40:00 +0000 | [diff] [blame] | 3357 | machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0); |
| 3358 | if (machine_opts) { |
| 3359 | kernel_filename = qemu_opt_get(machine_opts, "kernel"); |
| 3360 | initrd_filename = qemu_opt_get(machine_opts, "initrd"); |
| 3361 | kernel_cmdline = qemu_opt_get(machine_opts, "append"); |
| 3362 | } else { |
| 3363 | kernel_filename = initrd_filename = kernel_cmdline = NULL; |
| 3364 | } |
| 3365 | |
Peter Maydell | a0abe47 | 2012-02-08 05:41:39 +0000 | [diff] [blame] | 3366 | if (!kernel_cmdline) { |
| 3367 | kernel_cmdline = ""; |
| 3368 | } |
| 3369 | |
bellard | a20dd50 | 2003-09-30 21:07:02 +0000 | [diff] [blame] | 3370 | linux_boot = (kernel_filename != NULL); |
balrog | 6c41b27 | 2007-11-17 12:12:29 +0000 | [diff] [blame] | 3371 | |
ths | f8d39c0 | 2008-07-03 10:01:15 +0000 | [diff] [blame] | 3372 | if (!linux_boot && *kernel_cmdline != '\0') { |
| 3373 | fprintf(stderr, "-append only allowed with -kernel option\n"); |
| 3374 | exit(1); |
| 3375 | } |
| 3376 | |
| 3377 | if (!linux_boot && initrd_filename != NULL) { |
| 3378 | fprintf(stderr, "-initrd only allowed with -kernel option\n"); |
| 3379 | exit(1); |
| 3380 | } |
| 3381 | |
Grant Likely | 412beee | 2012-03-02 11:56:38 +0000 | [diff] [blame] | 3382 | if (!linux_boot && machine_opts && qemu_opt_get(machine_opts, "dtb")) { |
| 3383 | fprintf(stderr, "-dtb only allowed with -kernel option\n"); |
| 3384 | exit(1); |
| 3385 | } |
| 3386 | |
Jes Sorensen | 9156d76 | 2010-06-10 11:42:30 +0200 | [diff] [blame] | 3387 | os_set_line_buffering(); |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 3388 | |
aliguori | 7183b4b | 2008-11-05 20:40:18 +0000 | [diff] [blame] | 3389 | if (init_timer_alarm() < 0) { |
| 3390 | fprintf(stderr, "could not initialize alarm timer\n"); |
| 3391 | exit(1); |
| 3392 | } |
Max Filippov | 0abe905 | 2011-11-10 15:38:42 +0400 | [diff] [blame] | 3393 | |
Alon Levy | ad1be89 | 2012-03-14 20:33:37 +0200 | [diff] [blame] | 3394 | #ifdef CONFIG_SPICE |
| 3395 | /* spice needs the timers to be initialized by this point */ |
| 3396 | qemu_spice_init(); |
| 3397 | #endif |
| 3398 | |
Max Filippov | 0abe905 | 2011-11-10 15:38:42 +0400 | [diff] [blame] | 3399 | if (icount_option && (kvm_enabled() || xen_enabled())) { |
| 3400 | fprintf(stderr, "-icount is not allowed with kvm or xen\n"); |
| 3401 | exit(1); |
| 3402 | } |
Paolo Bonzini | 4e3de9e | 2010-03-10 11:38:48 +0100 | [diff] [blame] | 3403 | configure_icount(icount_option); |
pbrook | 634fce9 | 2006-07-15 17:40:09 +0000 | [diff] [blame] | 3404 | |
Mark McLoughlin | dc1c9fe | 2009-10-06 12:17:16 +0100 | [diff] [blame] | 3405 | if (net_init_clients() < 0) { |
| 3406 | exit(1); |
bellard | 702c651 | 2004-04-02 21:21:32 +0000 | [diff] [blame] | 3407 | } |
bellard | f1510b2 | 2003-06-25 00:07:40 +0000 | [diff] [blame] | 3408 | |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 3409 | /* init the bluetooth world */ |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 3410 | if (foreach_device_config(DEV_BT, bt_parse)) |
| 3411 | exit(1); |
balrog | dc72ac1 | 2008-11-09 00:04:26 +0000 | [diff] [blame] | 3412 | |
Anthony PERARD | 834e76e | 2011-07-20 08:17:44 +0000 | [diff] [blame] | 3413 | if (!xen_enabled()) { |
| 3414 | /* On 32-bit hosts, QEMU is limited by virtual address space */ |
| 3415 | if (ram_size > (2047 << 20) && HOST_LONG_BITS == 32) { |
| 3416 | fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n"); |
| 3417 | exit(1); |
| 3418 | } |
| 3419 | } |
balrog | 7fb4fdc | 2008-04-24 17:59:27 +0000 | [diff] [blame] | 3420 | |
Jan Kiszka | d5ab971 | 2011-08-02 16:10:21 +0200 | [diff] [blame] | 3421 | cpu_exec_init_all(); |
bellard | 26a5f13 | 2008-05-28 12:30:31 +0000 | [diff] [blame] | 3422 | |
Markus Armbruster | eb85201 | 2009-10-27 18:41:44 +0100 | [diff] [blame] | 3423 | bdrv_init_with_whitelist(); |
ths | e4bcb14 | 2007-12-02 04:51:10 +0000 | [diff] [blame] | 3424 | |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 3425 | blk_mig_init(); |
| 3426 | |
ths | 96d30e4 | 2007-01-07 20:42:14 +0000 | [diff] [blame] | 3427 | /* open the virtual block devices */ |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 3428 | if (snapshot) |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3429 | qemu_opts_foreach(qemu_find_opts("drive"), drive_enable_snapshot, NULL, 0); |
| 3430 | if (qemu_opts_foreach(qemu_find_opts("drive"), drive_init_func, &machine->use_scsi, 1) != 0) |
Gerd Hoffmann | 9dfd7c7 | 2009-07-22 16:43:04 +0200 | [diff] [blame] | 3431 | exit(1); |
balrog | 3e3d581 | 2007-04-30 02:09:25 +0000 | [diff] [blame] | 3432 | |
Markus Armbruster | 4e5d9b5 | 2011-01-28 11:21:45 +0100 | [diff] [blame] | 3433 | default_drive(default_cdrom, snapshot, machine->use_scsi, |
| 3434 | IF_DEFAULT, 2, CDROM_OPTS); |
| 3435 | default_drive(default_floppy, snapshot, machine->use_scsi, |
| 3436 | IF_FLOPPY, 0, FD_OPTS); |
| 3437 | default_drive(default_sdcard, snapshot, machine->use_scsi, |
| 3438 | IF_SD, 0, SD_OPTS); |
| 3439 | |
Alex Williamson | 97ab12d | 2010-06-25 11:09:50 -0600 | [diff] [blame] | 3440 | register_savevm_live(NULL, "ram", 0, 4, NULL, ram_save_live, NULL, |
lirans@il.ibm.com | c163b5c | 2009-11-02 15:40:58 +0200 | [diff] [blame] | 3441 | ram_load, NULL); |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 3442 | |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 3443 | if (nb_numa_nodes > 0) { |
| 3444 | int i; |
| 3445 | |
Sasha Levin | ea0e541 | 2011-06-29 23:29:39 -0400 | [diff] [blame] | 3446 | if (nb_numa_nodes > MAX_NODES) { |
| 3447 | nb_numa_nodes = MAX_NODES; |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 3448 | } |
| 3449 | |
| 3450 | /* If no memory size if given for any node, assume the default case |
| 3451 | * and distribute the available memory equally across all nodes |
| 3452 | */ |
| 3453 | for (i = 0; i < nb_numa_nodes; i++) { |
| 3454 | if (node_mem[i] != 0) |
| 3455 | break; |
| 3456 | } |
| 3457 | if (i == nb_numa_nodes) { |
| 3458 | uint64_t usedmem = 0; |
| 3459 | |
| 3460 | /* On Linux, the each node's border has to be 8MB aligned, |
| 3461 | * the final node gets the rest. |
| 3462 | */ |
| 3463 | for (i = 0; i < nb_numa_nodes - 1; i++) { |
| 3464 | node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1); |
| 3465 | usedmem += node_mem[i]; |
| 3466 | } |
| 3467 | node_mem[i] = ram_size - usedmem; |
| 3468 | } |
| 3469 | |
| 3470 | for (i = 0; i < nb_numa_nodes; i++) { |
| 3471 | if (node_cpumask[i] != 0) |
| 3472 | break; |
| 3473 | } |
| 3474 | /* assigning the VCPUs round-robin is easier to implement, guest OSes |
| 3475 | * must cope with this anyway, because there are BIOSes out there in |
| 3476 | * real machines which also use this scheme. |
| 3477 | */ |
| 3478 | if (i == nb_numa_nodes) { |
Vasilis Liaskovitis | 991dfef | 2011-10-26 14:19:00 +0200 | [diff] [blame] | 3479 | for (i = 0; i < max_cpus; i++) { |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 3480 | node_cpumask[i % nb_numa_nodes] |= 1 << i; |
| 3481 | } |
| 3482 | } |
| 3483 | } |
| 3484 | |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3485 | if (qemu_opts_foreach(qemu_find_opts("mon"), mon_init_func, NULL, 1) != 0) { |
Jan Kiszka | 157b931 | 2010-04-06 16:55:53 +0200 | [diff] [blame] | 3486 | exit(1); |
| 3487 | } |
| 3488 | |
Gerd Hoffmann | 998bbd7 | 2009-12-08 13:11:41 +0100 | [diff] [blame] | 3489 | if (foreach_device_config(DEV_SERIAL, serial_parse) < 0) |
| 3490 | exit(1); |
Gerd Hoffmann | 6a5e8b0 | 2009-12-08 13:11:42 +0100 | [diff] [blame] | 3491 | if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0) |
| 3492 | exit(1); |
Gerd Hoffmann | aee1b93 | 2009-12-08 13:11:53 +0100 | [diff] [blame] | 3493 | if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0) |
| 3494 | exit(1); |
H. Peter Anvin | c9f398e | 2009-12-29 13:51:36 -0800 | [diff] [blame] | 3495 | if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0) |
| 3496 | exit(1); |
aliguori | 2796dae | 2009-01-16 20:23:27 +0000 | [diff] [blame] | 3497 | |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 3498 | /* If no default VGA is requested, the default is "none". */ |
| 3499 | if (default_vga && cirrus_vga_available()) { |
| 3500 | vga_model = "cirrus"; |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 3501 | } |
Paolo Bonzini | 7f1b17f | 2012-05-10 09:39:17 +0200 | [diff] [blame] | 3502 | select_vgahw(vga_model); |
Blue Swirl | a369da5 | 2011-09-27 19:15:42 +0000 | [diff] [blame] | 3503 | |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3504 | if (qemu_opts_foreach(qemu_find_opts("device"), device_help_func, NULL, 0) != 0) |
Markus Armbruster | ff952ba | 2010-01-29 19:48:57 +0100 | [diff] [blame] | 3505 | exit(0); |
| 3506 | |
Markus Armbruster | 09aaa16 | 2009-08-21 10:31:34 +0200 | [diff] [blame] | 3507 | if (watchdog) { |
| 3508 | i = select_watchdog(watchdog); |
| 3509 | if (i > 0) |
| 3510 | exit (i == 1 ? 1 : 0); |
| 3511 | } |
| 3512 | |
Gerd Hoffmann | b6b6114 | 2009-07-15 13:48:21 +0200 | [diff] [blame] | 3513 | if (machine->compat_props) { |
Gerd Hoffmann | 458fb67 | 2009-12-08 13:11:33 +0100 | [diff] [blame] | 3514 | qdev_prop_register_global_list(machine->compat_props); |
Gerd Hoffmann | b6b6114 | 2009-07-15 13:48:21 +0200 | [diff] [blame] | 3515 | } |
Gerd Hoffmann | d0fef6f | 2009-12-08 13:11:34 +0100 | [diff] [blame] | 3516 | qemu_add_globals(); |
| 3517 | |
Anthony Liguori | 1de81d2 | 2011-12-19 16:37:46 -0600 | [diff] [blame] | 3518 | qdev_machine_init(); |
| 3519 | |
Paul Brook | fbe1b59 | 2009-05-13 17:56:25 +0100 | [diff] [blame] | 3520 | machine->init(ram_size, boot_devices, |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3521 | kernel_filename, kernel_cmdline, initrd_filename, cpu_model); |
| 3522 | |
Jan Kiszka | ea375f9 | 2010-03-01 19:10:30 +0100 | [diff] [blame] | 3523 | cpu_synchronize_all_post_init(); |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 3524 | |
Blue Swirl | 87d0a28 | 2010-03-27 18:24:45 +0000 | [diff] [blame] | 3525 | set_numa_modes(); |
aliguori | 268a362 | 2009-04-21 22:30:27 +0000 | [diff] [blame] | 3526 | |
aliguori | 6f338c3 | 2009-02-11 15:21:54 +0000 | [diff] [blame] | 3527 | current_machine = machine; |
| 3528 | |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3529 | /* init USB devices */ |
| 3530 | if (usb_enabled) { |
Markus Armbruster | 0752706 | 2009-10-06 12:16:57 +0100 | [diff] [blame] | 3531 | if (foreach_device_config(DEV_USB, usb_parse) < 0) |
| 3532 | exit(1); |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3533 | } |
| 3534 | |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 3535 | /* init generic devices */ |
Gerd Hoffmann | 3329f07 | 2010-08-20 13:52:01 +0200 | [diff] [blame] | 3536 | if (qemu_opts_foreach(qemu_find_opts("device"), device_init_func, NULL, 1) != 0) |
Gerd Hoffmann | bd3c948 | 2009-07-15 13:59:26 +0200 | [diff] [blame] | 3537 | exit(1); |
| 3538 | |
Markus Armbruster | 668680f | 2010-02-11 14:44:58 +0100 | [diff] [blame] | 3539 | net_check_clients(); |
| 3540 | |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3541 | /* just use the first displaystate for the moment */ |
Paolo Bonzini | b473df6 | 2010-02-11 00:29:55 +0100 | [diff] [blame] | 3542 | ds = get_displaystate(); |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3543 | |
Gerd Hoffmann | a3e2226 | 2010-08-25 15:32:06 +0200 | [diff] [blame] | 3544 | if (using_spice) |
| 3545 | display_remote++; |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3546 | if (display_type == DT_DEFAULT && !display_remote) { |
Anthony Liguori | f92f8af | 2009-05-20 13:01:02 -0500 | [diff] [blame] | 3547 | #if defined(CONFIG_SDL) || defined(CONFIG_COCOA) |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3548 | display_type = DT_SDL; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3549 | #elif defined(CONFIG_VNC) |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3550 | vnc_display = "localhost:0,to=99"; |
| 3551 | show_vnc_port = 1; |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3552 | #else |
| 3553 | display_type = DT_NONE; |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3554 | #endif |
| 3555 | } |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3556 | |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3557 | |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3558 | /* init local displays */ |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3559 | switch (display_type) { |
| 3560 | case DT_NOGRAPHIC: |
| 3561 | break; |
| 3562 | #if defined(CONFIG_CURSES) |
| 3563 | case DT_CURSES: |
| 3564 | curses_display_init(ds, full_screen); |
| 3565 | break; |
| 3566 | #endif |
bellard | 5b0753e | 2005-03-01 21:37:28 +0000 | [diff] [blame] | 3567 | #if defined(CONFIG_SDL) |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3568 | case DT_SDL: |
| 3569 | sdl_display_init(ds, full_screen, no_frame); |
| 3570 | break; |
bellard | 5b0753e | 2005-03-01 21:37:28 +0000 | [diff] [blame] | 3571 | #elif defined(CONFIG_COCOA) |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3572 | case DT_SDL: |
| 3573 | cocoa_display_init(ds, full_screen); |
| 3574 | break; |
bellard | 313aa56 | 2003-08-10 21:52:11 +0000 | [diff] [blame] | 3575 | #endif |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3576 | default: |
| 3577 | break; |
| 3578 | } |
| 3579 | |
Gleb Natapov | 0ce235a | 2011-03-31 11:27:23 +0200 | [diff] [blame] | 3580 | /* must be after terminal init, SDL library changes signal handlers */ |
| 3581 | os_setup_signal_handling(); |
| 3582 | |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3583 | #ifdef CONFIG_VNC |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3584 | /* init remote displays */ |
| 3585 | if (vnc_display) { |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3586 | vnc_display_init(ds); |
| 3587 | if (vnc_display_open(ds, vnc_display) < 0) |
| 3588 | exit(1); |
Anthony Liguori | f92f8af | 2009-05-20 13:01:02 -0500 | [diff] [blame] | 3589 | |
Anthony Liguori | 993fbfd | 2009-05-21 16:54:00 -0500 | [diff] [blame] | 3590 | if (show_vnc_port) { |
| 3591 | printf("VNC server running on `%s'\n", vnc_display_local_addr(ds)); |
Anthony Liguori | f92f8af | 2009-05-20 13:01:02 -0500 | [diff] [blame] | 3592 | } |
bellard | 313aa56 | 2003-08-10 21:52:11 +0000 | [diff] [blame] | 3593 | } |
Jes Sorensen | 821601e | 2011-03-16 13:33:36 +0100 | [diff] [blame] | 3594 | #endif |
Gerd Hoffmann | a3e2226 | 2010-08-25 15:32:06 +0200 | [diff] [blame] | 3595 | #ifdef CONFIG_SPICE |
Gerd Hoffmann | a19cbfb | 2010-04-27 11:50:11 +0200 | [diff] [blame] | 3596 | if (using_spice && !qxl_enabled) { |
Gerd Hoffmann | a3e2226 | 2010-08-25 15:32:06 +0200 | [diff] [blame] | 3597 | qemu_spice_display_init(ds); |
| 3598 | } |
| 3599 | #endif |
aliguori | 5b08fc1 | 2008-08-21 20:08:03 +0000 | [diff] [blame] | 3600 | |
Gerd Hoffmann | 6b62dc2 | 2010-08-25 10:51:06 +0200 | [diff] [blame] | 3601 | /* display setup */ |
| 3602 | dpy_resize(ds); |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3603 | dcl = ds->listeners; |
| 3604 | while (dcl != NULL) { |
| 3605 | if (dcl->dpy_refresh != NULL) { |
Paolo Bonzini | 7bd427d | 2011-03-11 16:47:48 +0100 | [diff] [blame] | 3606 | ds->gui_timer = qemu_new_timer_ms(rt_clock, gui_update, ds); |
| 3607 | qemu_mod_timer(ds->gui_timer, qemu_get_clock_ms(rt_clock)); |
Isaku Yamahata | 0f2ad63 | 2010-05-27 14:38:47 +0900 | [diff] [blame] | 3608 | break; |
ths | 20d8a3e | 2007-02-18 17:04:49 +0000 | [diff] [blame] | 3609 | } |
aliguori | 3023f33 | 2009-01-16 19:04:14 +0000 | [diff] [blame] | 3610 | dcl = dcl->next; |
bellard | 82c643f | 2004-07-14 17:28:13 +0000 | [diff] [blame] | 3611 | } |
Paolo Bonzini | b473df6 | 2010-02-11 00:29:55 +0100 | [diff] [blame] | 3612 | text_consoles_set_display(ds); |
aliguori | 2796dae | 2009-01-16 20:23:27 +0000 | [diff] [blame] | 3613 | |
Markus Armbruster | ef0c4a0 | 2012-02-07 15:09:13 +0100 | [diff] [blame] | 3614 | if (foreach_device_config(DEV_GDB, gdbserver_start) < 0) { |
aliguori | 59030a8 | 2009-04-05 18:43:41 +0000 | [diff] [blame] | 3615 | exit(1); |
balrog | 45669e0 | 2007-07-02 13:20:17 +0000 | [diff] [blame] | 3616 | } |
balrog | 45669e0 | 2007-07-02 13:20:17 +0000 | [diff] [blame] | 3617 | |
Gerd Hoffmann | 3418bd2 | 2009-09-25 21:42:41 +0200 | [diff] [blame] | 3618 | qdev_machine_creation_done(); |
| 3619 | |
Gerd Hoffmann | 15ff770 | 2009-12-14 16:07:35 +0100 | [diff] [blame] | 3620 | if (rom_load_all() != 0) { |
| 3621 | fprintf(stderr, "rom loading failed\n"); |
| 3622 | exit(1); |
| 3623 | } |
Gerd Hoffmann | 45a50b1 | 2009-10-01 16:42:33 +0200 | [diff] [blame] | 3624 | |
Isaku Yamahata | 80376c3 | 2010-12-20 14:33:35 +0900 | [diff] [blame] | 3625 | /* TODO: once all bus devices are qdevified, this should be done |
| 3626 | * when bus is created by qdev.c */ |
| 3627 | qemu_register_reset(qbus_reset_all_fn, sysbus_get_default()); |
Gleb Natapov | 4cab946 | 2010-12-08 13:35:08 +0200 | [diff] [blame] | 3628 | qemu_run_machine_init_done_notifiers(); |
| 3629 | |
Jan Kiszka | e063eb1 | 2011-06-14 18:29:43 +0200 | [diff] [blame] | 3630 | qemu_system_reset(VMRESET_SILENT); |
Juan Quintela | 05f2401 | 2009-08-20 19:42:22 +0200 | [diff] [blame] | 3631 | if (loadvm) { |
Markus Armbruster | 03cd465 | 2010-02-17 16:24:10 +0100 | [diff] [blame] | 3632 | if (load_vmstate(loadvm) < 0) { |
Juan Quintela | 05f2401 | 2009-08-20 19:42:22 +0200 | [diff] [blame] | 3633 | autostart = 0; |
| 3634 | } |
| 3635 | } |
bellard | d63d307 | 2004-10-03 13:29:03 +0000 | [diff] [blame] | 3636 | |
Glauber Costa | 2bb8c10 | 2009-07-24 16:20:23 -0400 | [diff] [blame] | 3637 | if (incoming) { |
Amos Kong | d5c5dac | 2012-05-11 00:28:35 +0800 | [diff] [blame] | 3638 | Error *errp = NULL; |
| 3639 | int ret = qemu_start_incoming_migration(incoming, &errp); |
Juan Quintela | 8ca5e80 | 2010-06-09 14:10:54 +0200 | [diff] [blame] | 3640 | if (ret < 0) { |
Amos Kong | d5c5dac | 2012-05-11 00:28:35 +0800 | [diff] [blame] | 3641 | if (error_is_set(&errp)) { |
| 3642 | fprintf(stderr, "Migrate: %s\n", error_get_pretty(errp)); |
| 3643 | error_free(errp); |
| 3644 | } |
Juan Quintela | 8ca5e80 | 2010-06-09 14:10:54 +0200 | [diff] [blame] | 3645 | fprintf(stderr, "Migration failed. Exit code %s(%d), exiting.\n", |
| 3646 | incoming, ret); |
| 3647 | exit(ret); |
| 3648 | } |
Avi Kivity | 6b99dad | 2009-08-09 14:39:20 +0300 | [diff] [blame] | 3649 | } else if (autostart) { |
aliguori | c0f4ce7 | 2009-03-05 23:01:01 +0000 | [diff] [blame] | 3650 | vm_start(); |
Avi Kivity | 6b99dad | 2009-08-09 14:39:20 +0300 | [diff] [blame] | 3651 | } |
ths | ffd843b | 2006-12-21 19:46:43 +0000 | [diff] [blame] | 3652 | |
Jes Sorensen | eb505be | 2010-06-10 11:42:28 +0200 | [diff] [blame] | 3653 | os_setup_post(); |
ths | 71e3ceb | 2006-12-22 02:11:31 +0000 | [diff] [blame] | 3654 | |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 3655 | resume_all_vcpus(); |
bellard | 8a7ddc3 | 2004-03-31 19:00:16 +0000 | [diff] [blame] | 3656 | main_loop(); |
Paolo Bonzini | 9943590 | 2011-09-12 14:03:13 +0200 | [diff] [blame] | 3657 | bdrv_close_all(); |
| 3658 | pause_all_vcpus(); |
aliguori | 63a01ef | 2008-10-31 19:10:00 +0000 | [diff] [blame] | 3659 | net_cleanup(); |
wayne | 3d3b830 | 2011-07-27 18:04:55 +0800 | [diff] [blame] | 3660 | res_free(); |
ths | b46a890 | 2007-10-21 23:20:45 +0000 | [diff] [blame] | 3661 | |
bellard | 0824d6f | 2003-06-24 13:42:40 +0000 | [diff] [blame] | 3662 | return 0; |
| 3663 | } |