]> git.proxmox.com Git - mirror_qemu.git/blame - vl.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update Sparc docs, add -cpu flag
[mirror_qemu.git] / vl.c
CommitLineData
0824d6fc 1/*
80cabfad 2 * QEMU System Emulator
5fafdf24 3 *
68d0f70e 4 * Copyright (c) 2003-2008 Fabrice Bellard
5fafdf24 5 *
1df912cf
FB		 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.
0824d6fc 23 */
87ecb68b
PB		 24#include "hw/hw.h"
25#include "hw/boards.h"
26#include "hw/usb.h"
27#include "hw/pcmcia.h"
28#include "hw/pc.h"
87ecb68b
PB		 29#include "hw/audiodev.h"
30#include "hw/isa.h"
2e4d9fb1 31#include "hw/baum.h"
1ae26a18 32#include "hw/bt.h"
87ecb68b
PB		 33#include "net.h"
34#include "console.h"
35#include "sysemu.h"
36#include "gdbstub.h"
37#include "qemu-timer.h"
38#include "qemu-char.h"
39#include "block.h"
40#include "audio/audio.h"
67b915a5 41
0824d6fc 42#include <unistd.h>
0824d6fc
FB		 43#include <fcntl.h>
44#include <signal.h>
45#include <time.h>
0824d6fc 46#include <errno.h>
67b915a5 47#include <sys/time.h>
c88676f8 48#include <zlib.h>
67b915a5
FB		 49
50#ifndef _WIN32
51#include <sys/times.h>
f1510b2c 52#include <sys/wait.h>
67b915a5
FB		 53#include <termios.h>
54#include <sys/poll.h>
55#include <sys/mman.h>
f1510b2c
FB		 56#include <sys/ioctl.h>
57#include <sys/socket.h>
c94c8d64 58#include <netinet/in.h>
9d728e8c 59#include <dirent.h>
7c9d8e07 60#include <netdb.h>
cb4b976b
TS		 61#include <sys/select.h>
62#include <arpa/inet.h>
7d3505c5
FB		 63#ifdef _BSD
64#include <sys/stat.h>
128ab2ff 65#if !defined(__APPLE__) && !defined(__OpenBSD__)
7d3505c5 66#include <libutil.h>
83fb7adf 67#endif
128ab2ff
BS		 68#ifdef __OpenBSD__
69#include <net/if.h>
70#endif
5c40d2bd
TS		 71#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72#include <freebsd/stdlib.h>
7d3505c5 73#else
223f0d72 74#ifdef __linux__
f1510b2c
FB		 75#include <linux/if.h>
76#include <linux/if_tun.h>
7d3505c5
FB		 77#include <pty.h>
78#include <malloc.h>
fd872598 79#include <linux/rtc.h>
bd494f4c
TS		 80
81/* For the benefit of older linux systems which don't supply it,
82 we use a local copy of hpet.h. */
83/* #include <linux/hpet.h> */
84#include "hpet.h"
85
e57a8c0e 86#include <linux/ppdev.h>
5867c88a 87#include <linux/parport.h>
223f0d72
BS		 88#endif
89#ifdef __sun__
d5d10bc3
TS		 90#include <sys/stat.h>
91#include <sys/ethernet.h>
92#include <sys/sockio.h>
d5d10bc3
TS		 93#include <netinet/arp.h>
94#include <netinet/in.h>
95#include <netinet/in_systm.h>
96#include <netinet/ip.h>
97#include <netinet/ip_icmp.h> // must come after ip.h
98#include <netinet/udp.h>
99#include <netinet/tcp.h>
100#include <net/if.h>
101#include <syslog.h>
102#include <stropts.h>
67b915a5 103#endif
7d3505c5 104#endif
ec530c81 105#endif
67b915a5 106
03ff3ca3
AL		 107#include "qemu_socket.h"
108
c20709aa
FB		 109#if defined(CONFIG_SLIRP)
110#include "libslirp.h"
111#endif
112
9892fbfb
BS		 113#if defined(__OpenBSD__)
114#include <util.h>
115#endif
116
8a16d273
TS		 117#if defined(CONFIG_VDE)
118#include <libvdeplug.h>
119#endif
120
67b915a5 121#ifdef _WIN32
7d3505c5 122#include <malloc.h>
67b915a5 123#include <sys/timeb.h>
4fddf62a 124#include <mmsystem.h>
67b915a5
FB		 125#define getopt_long_only getopt_long
126#define memalign(align, size) malloc(size)
127#endif
128
73332e5c 129#ifdef CONFIG_SDL
96bcd4f8 130#ifdef __APPLE__
83fb7adf 131#include <SDL/SDL.h>
96bcd4f8 132#endif
73332e5c 133#endif /* CONFIG_SDL */
0824d6fc 134
5b0753e0
FB		 135#ifdef CONFIG_COCOA
136#undef main
137#define main qemu_main
138#endif /* CONFIG_COCOA */
139
0824d6fc 140#include "disas.h"
fc01f7e7 141
8a7ddc38 142#include "exec-all.h"
0824d6fc 143
5a67135a 144#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
b46a8906 145#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
a14d6c8c
PB		 146#ifdef __sun__
147#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
148#else
149#define SMBD_COMMAND "/usr/sbin/smbd"
150#endif
f1510b2c 151
0824d6fc 152//#define DEBUG_UNUSED_IOPORT
fd872598 153//#define DEBUG_IOPORT
9dc63a1e
BS		 154//#define DEBUG_NET
155//#define DEBUG_SLIRP
330d0414 156
77d4bc34
FB		 157#ifdef TARGET_PPC
158#define DEFAULT_RAM_SIZE 144
159#else
1bfe856e 160#define DEFAULT_RAM_SIZE 128
77d4bc34 161#endif
313aa567 162
0d92ed30
PB		 163/* Max number of USB devices that can be specified on the commandline. */
164#define MAX_USB_CMDLINE 8
165
7dea1da4
FB		 166/* XXX: use a two level table to limit memory usage */
167#define MAX_IOPORTS 65536
0824d6fc 168
80cabfad 169const char *bios_dir = CONFIG_QEMU_SHAREDIR;
1192dad8 170const char *bios_name = NULL;
dbed7e40
BS		 171static void *ioport_opaque[MAX_IOPORTS];
172static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
173static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
e4bcb14c 174/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
faea38e7 175 to store the VM snapshots */
e4bcb14c
TS		 176DriveInfo drives_table[MAX_DRIVES+1];
177int nb_drives;
faea38e7 178/* point to the block driver where the snapshots are managed */
dbed7e40
BS		 179static BlockDriverState *bs_snapshots;
180static int vga_ram_size;
cb5a7aa8 181enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
313aa567 182static DisplayState display_state;
a20dd508 183int nographic;
dbed7e40 184static int curses;
3d11d0eb 185const char* keyboard_layout = NULL;
313aa567 186int64_t ticks_per_sec;
00f82b8a 187ram_addr_t ram_size;
c4b1fcc0 188int nb_nics;
7c9d8e07 189NICInfo nd_table[MAX_NICS];
8a7ddc38 190int vm_running;
f6503059
AZ		 191static int rtc_utc = 1;
192static int rtc_date_offset = -1; /* -1 means no change */
1bfe856e 193int cirrus_vga_enabled = 1;
d34cab9f 194int vmsvga_enabled = 0;
d827220b
FB		 195#ifdef TARGET_SPARC
196int graphic_width = 1024;
197int graphic_height = 768;
eee0b836 198int graphic_depth = 8;
d827220b 199#else
1bfe856e
FB		 200int graphic_width = 800;
201int graphic_height = 600;
e9b137c2 202int graphic_depth = 15;
eee0b836 203#endif
dbed7e40
BS		 204static int full_screen = 0;
205static int no_frame = 0;
667accab 206int no_quit = 0;
8d11df9e 207CharDriverState *serial_hds[MAX_SERIAL_PORTS];
6508fe59 208CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
a09db21f
FB		 209#ifdef TARGET_I386
210int win2k_install_hack = 0;
211#endif
bb36d470 212int usb_enabled = 0;
7c9d8e07 213static VLANState *first_vlan;
6a00d601 214int smp_cpus = 1;
73fc9742 215const char *vnc_display;
d3e9db93 216#if defined(TARGET_SPARC)
ba3c64fb 217#define MAX_CPUS 16
d3e9db93
FB		 218#elif defined(TARGET_I386)
219#define MAX_CPUS 255
ba3c64fb 220#else
d3e9db93 221#define MAX_CPUS 1
ba3c64fb 222#endif
6515b203 223int acpi_enabled = 1;
52ca8d6a 224int fd_bootchk = 1;
d1beab82 225int no_reboot = 0;
b2f76161 226int no_shutdown = 0;
9467cd46 227int cursor_hide = 1;
a171fe39 228int graphic_rotate = 0;
71e3ceb8 229int daemonize = 0;
9ae02555
TS		 230const char *option_rom[MAX_OPTION_ROMS];
231int nb_option_roms;
8e71621f 232int semihosting_enabled = 0;
3c07f8e8 233int autostart = 1;
2b8f2d41
AZ		 234#ifdef TARGET_ARM
235int old_param = 0;
236#endif
c35734b2 237const char *qemu_name;
3780e197 238int alt_grab = 0;
66508601
BS		 239#ifdef TARGET_SPARC
240unsigned int nb_prom_envs = 0;
241const char *prom_envs[MAX_PROM_ENVS];
242#endif
dbed7e40
BS		 243static int nb_drives_opt;
244static struct drive_opt {
609497ab
AZ		 245 const char *file;
246 char opt[1024];
247} drives_opt[MAX_DRIVES];
0824d6fc 248
ee5605e5
AZ		 249static CPUState *cur_cpu;
250static CPUState *next_cpu;
76ea08f9 251static int event_pending = 1;
bf20dc07 252/* Conversion factor from emulated instructions to virtual clock ticks. */
2e70f6ef 253static int icount_time_shift;
bf20dc07 254/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
2e70f6ef
PB		 255#define MAX_ICOUNT_SHIFT 10
256/* Compensate for varying guest execution speed. */
257static int64_t qemu_icount_bias;
dbed7e40
BS		 258static QEMUTimer *icount_rt_timer;
259static QEMUTimer *icount_vm_timer;
ee5605e5 260
8fcb1b90
BS		 261uint8_t qemu_uuid[16];
262
aeb30be6
AZ		 263#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
264
0824d6fc 265/***********************************************************/
26aa7d72
FB		 266/* x86 ISA bus support */
267
268target_phys_addr_t isa_mem_base = 0;
3de388f6 269PicState2 *isa_pic;
0824d6fc 270
477e3edf
AL		 271static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
272static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
273
274static uint32_t ioport_read(int index, uint32_t address)
275{
276 static IOPortReadFunc *default_func[3] = {
277 default_ioport_readb,
278 default_ioport_readw,
279 default_ioport_readl
280 };
281 IOPortReadFunc *func = ioport_read_table[index][address];
282 if (!func)
283 func = default_func[index];
284 return func(ioport_opaque[address], address);
285}
286
287static void ioport_write(int index, uint32_t address, uint32_t data)
288{
289 static IOPortWriteFunc *default_func[3] = {
290 default_ioport_writeb,
291 default_ioport_writew,
292 default_ioport_writel
293 };
294 IOPortWriteFunc *func = ioport_write_table[index][address];
295 if (!func)
296 func = default_func[index];
297 func(ioport_opaque[address], address, data);
298}
299
9596ebb7 300static uint32_t default_ioport_readb(void *opaque, uint32_t address)
0824d6fc
FB		 301{
302#ifdef DEBUG_UNUSED_IOPORT
1196be37 303 fprintf(stderr, "unused inb: port=0x%04x\n", address);
0824d6fc 304#endif
fc01f7e7 305 return 0xff;
0824d6fc
FB		 306}
307
9596ebb7 308static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
0824d6fc
FB		 309{
310#ifdef DEBUG_UNUSED_IOPORT
1196be37 311 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
0824d6fc
FB		 312#endif
313}
314
315/* default is to make two byte accesses */
9596ebb7 316static uint32_t default_ioport_readw(void *opaque, uint32_t address)
0824d6fc
FB		 317{
318 uint32_t data;
477e3edf 319 data = ioport_read(0, address);
db45c29a 320 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 321 data |= ioport_read(0, address) << 8;
0824d6fc
FB		 322 return data;
323}
324
9596ebb7 325static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
0824d6fc 326{
477e3edf 327 ioport_write(0, address, data & 0xff);
db45c29a 328 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 329 ioport_write(0, address, (data >> 8) & 0xff);
0824d6fc
FB		 330}
331
9596ebb7 332static uint32_t default_ioport_readl(void *opaque, uint32_t address)
0824d6fc 333{
fc01f7e7 334#ifdef DEBUG_UNUSED_IOPORT
1196be37 335 fprintf(stderr, "unused inl: port=0x%04x\n", address);
fc01f7e7
FB		 336#endif
337 return 0xffffffff;
0824d6fc
FB		 338}
339
9596ebb7 340static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
0824d6fc 341{
fc01f7e7 342#ifdef DEBUG_UNUSED_IOPORT
1196be37 343 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
fc01f7e7 344#endif
0824d6fc
FB		 345}
346
fc01f7e7 347/* size is the word size in byte */
5fafdf24 348int register_ioport_read(int start, int length, int size,
c4b1fcc0 349 IOPortReadFunc *func, void *opaque)
f1510b2c 350{
fc01f7e7 351 int i, bsize;
f1510b2c 352
c4b1fcc0 353 if (size == 1) {
fc01f7e7 354 bsize = 0;
c4b1fcc0 355 } else if (size == 2) {
fc01f7e7 356 bsize = 1;
c4b1fcc0 357 } else if (size == 4) {
fc01f7e7 358 bsize = 2;
c4b1fcc0 359 } else {
88fdf56f 360 hw_error("register_ioport_read: invalid size");
fc01f7e7 361 return -1;
c4b1fcc0
FB		 362 }
363 for(i = start; i < start + length; i += size) {
fc01f7e7 364 ioport_read_table[bsize][i] = func;
c4b1fcc0 365 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
88fdf56f 366 hw_error("register_ioport_read: invalid opaque");
c4b1fcc0
FB		 367 ioport_opaque[i] = opaque;
368 }
f1510b2c
FB		 369 return 0;
370}
371
fc01f7e7 372/* size is the word size in byte */
5fafdf24 373int register_ioport_write(int start, int length, int size,
c4b1fcc0 374 IOPortWriteFunc *func, void *opaque)
f1510b2c 375{
fc01f7e7 376 int i, bsize;
f1510b2c 377
c4b1fcc0 378 if (size == 1) {
fc01f7e7 379 bsize = 0;
c4b1fcc0 380 } else if (size == 2) {
fc01f7e7 381 bsize = 1;
c4b1fcc0 382 } else if (size == 4) {
fc01f7e7 383 bsize = 2;
c4b1fcc0 384 } else {
88fdf56f 385 hw_error("register_ioport_write: invalid size");
fc01f7e7 386 return -1;
c4b1fcc0
FB		 387 }
388 for(i = start; i < start + length; i += size) {
fc01f7e7 389 ioport_write_table[bsize][i] = func;
88fdf56f
AZ		 390 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
391 hw_error("register_ioport_write: invalid opaque");
c4b1fcc0
FB		 392 ioport_opaque[i] = opaque;
393 }
f1510b2c
FB		 394 return 0;
395}
396
69b91039
FB		 397void isa_unassign_ioport(int start, int length)
398{
399 int i;
400
401 for(i = start; i < start + length; i++) {
402 ioport_read_table[0][i] = default_ioport_readb;
403 ioport_read_table[1][i] = default_ioport_readw;
404 ioport_read_table[2][i] = default_ioport_readl;
405
406 ioport_write_table[0][i] = default_ioport_writeb;
407 ioport_write_table[1][i] = default_ioport_writew;
408 ioport_write_table[2][i] = default_ioport_writel;
409 }
410}
411
20f32282
FB		 412/***********************************************************/
413
c45886db 414void cpu_outb(CPUState *env, int addr, int val)
0824d6fc 415{
fd872598
FB		 416#ifdef DEBUG_IOPORT
417 if (loglevel & CPU_LOG_IOPORT)
418 fprintf(logfile, "outb: %04x %02x\n", addr, val);
3b46e624 419#endif
477e3edf 420 ioport_write(0, addr, val);
89bfc105
FB		 421#ifdef USE_KQEMU
422 if (env)
423 env->last_io_time = cpu_get_time_fast();
424#endif
0824d6fc
FB		 425}
426
c45886db 427void cpu_outw(CPUState *env, int addr, int val)
0824d6fc 428{
fd872598
FB		 429#ifdef DEBUG_IOPORT
430 if (loglevel & CPU_LOG_IOPORT)
431 fprintf(logfile, "outw: %04x %04x\n", addr, val);
3b46e624 432#endif
477e3edf 433 ioport_write(1, addr, val);
89bfc105
FB		 434#ifdef USE_KQEMU
435 if (env)
436 env->last_io_time = cpu_get_time_fast();
437#endif
0824d6fc
FB		 438}
439
c45886db 440void cpu_outl(CPUState *env, int addr, int val)
0824d6fc 441{
fd872598
FB		 442#ifdef DEBUG_IOPORT
443 if (loglevel & CPU_LOG_IOPORT)
444 fprintf(logfile, "outl: %04x %08x\n", addr, val);
445#endif
477e3edf 446 ioport_write(2, addr, val);
89bfc105
FB		 447#ifdef USE_KQEMU
448 if (env)
449 env->last_io_time = cpu_get_time_fast();
450#endif
0824d6fc
FB		 451}
452
c45886db 453int cpu_inb(CPUState *env, int addr)
0824d6fc 454{
fd872598 455 int val;
477e3edf 456 val = ioport_read(0, addr);
fd872598
FB		 457#ifdef DEBUG_IOPORT
458 if (loglevel & CPU_LOG_IOPORT)
459 fprintf(logfile, "inb : %04x %02x\n", addr, val);
89bfc105
FB		 460#endif
461#ifdef USE_KQEMU
462 if (env)
463 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 464#endif
465 return val;
0824d6fc
FB		 466}
467
c45886db 468int cpu_inw(CPUState *env, int addr)
0824d6fc 469{
fd872598 470 int val;
477e3edf 471 val = ioport_read(1, addr);
fd872598
FB		 472#ifdef DEBUG_IOPORT
473 if (loglevel & CPU_LOG_IOPORT)
474 fprintf(logfile, "inw : %04x %04x\n", addr, val);
89bfc105
FB		 475#endif
476#ifdef USE_KQEMU
477 if (env)
478 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 479#endif
480 return val;
0824d6fc
FB		 481}
482
c45886db 483int cpu_inl(CPUState *env, int addr)
0824d6fc 484{
fd872598 485 int val;
477e3edf 486 val = ioport_read(2, addr);
fd872598
FB		 487#ifdef DEBUG_IOPORT
488 if (loglevel & CPU_LOG_IOPORT)
489 fprintf(logfile, "inl : %04x %08x\n", addr, val);
89bfc105
FB		 490#endif
491#ifdef USE_KQEMU
492 if (env)
493 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 494#endif
495 return val;
0824d6fc
FB		 496}
497
498/***********************************************************/
0824d6fc
FB		 499void hw_error(const char *fmt, ...)
500{
501 va_list ap;
6a00d601 502 CPUState *env;
0824d6fc
FB		 503
504 va_start(ap, fmt);
505 fprintf(stderr, "qemu: hardware error: ");
506 vfprintf(stderr, fmt, ap);
507 fprintf(stderr, "\n");
6a00d601
FB		 508 for(env = first_cpu; env != NULL; env = env->next_cpu) {
509 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
0824d6fc 510#ifdef TARGET_I386
6a00d601 511 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
c45886db 512#else
6a00d601 513 cpu_dump_state(env, stderr, fprintf, 0);
0824d6fc 514#endif
6a00d601 515 }
0824d6fc
FB		 516 va_end(ap);
517 abort();
518}
519
63066f4f
FB		 520/***********************************************************/
521/* keyboard/mouse */
522
523static QEMUPutKBDEvent *qemu_put_kbd_event;
524static void *qemu_put_kbd_event_opaque;
455204eb
TS		 525static QEMUPutMouseEntry *qemu_put_mouse_event_head;
526static QEMUPutMouseEntry *qemu_put_mouse_event_current;
63066f4f
FB		 527
528void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
529{
530 qemu_put_kbd_event_opaque = opaque;
531 qemu_put_kbd_event = func;
532}
533
455204eb
TS		 534QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
535 void *opaque, int absolute,
536 const char *name)
63066f4f 537{
455204eb
TS		 538 QEMUPutMouseEntry *s, *cursor;
539
540 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
541 if (!s)
542 return NULL;
543
544 s->qemu_put_mouse_event = func;
545 s->qemu_put_mouse_event_opaque = opaque;
546 s->qemu_put_mouse_event_absolute = absolute;
547 s->qemu_put_mouse_event_name = qemu_strdup(name);
548 s->next = NULL;
549
550 if (!qemu_put_mouse_event_head) {
551 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
552 return s;
553 }
554
555 cursor = qemu_put_mouse_event_head;
556 while (cursor->next != NULL)
557 cursor = cursor->next;
558
559 cursor->next = s;
560 qemu_put_mouse_event_current = s;
561
562 return s;
563}
564
565void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
566{
567 QEMUPutMouseEntry *prev = NULL, *cursor;
568
569 if (!qemu_put_mouse_event_head || entry == NULL)
570 return;
571
572 cursor = qemu_put_mouse_event_head;
573 while (cursor != NULL && cursor != entry) {
574 prev = cursor;
575 cursor = cursor->next;
576 }
577
578 if (cursor == NULL) // does not exist or list empty
579 return;
580 else if (prev == NULL) { // entry is head
581 qemu_put_mouse_event_head = cursor->next;
582 if (qemu_put_mouse_event_current == entry)
583 qemu_put_mouse_event_current = cursor->next;
584 qemu_free(entry->qemu_put_mouse_event_name);
585 qemu_free(entry);
586 return;
587 }
588
589 prev->next = entry->next;
590
591 if (qemu_put_mouse_event_current == entry)
592 qemu_put_mouse_event_current = prev;
593
594 qemu_free(entry->qemu_put_mouse_event_name);
595 qemu_free(entry);
63066f4f
FB		 596}
597
598void kbd_put_keycode(int keycode)
599{
600 if (qemu_put_kbd_event) {
601 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
602 }
603}
604
605void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
606{
455204eb
TS		 607 QEMUPutMouseEvent *mouse_event;
608 void *mouse_event_opaque;
a171fe39 609 int width;
455204eb
TS		 610
611 if (!qemu_put_mouse_event_current) {
612 return;
613 }
614
615 mouse_event =
616 qemu_put_mouse_event_current->qemu_put_mouse_event;
617 mouse_event_opaque =
618 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
619
620 if (mouse_event) {
a171fe39
AZ		 621 if (graphic_rotate) {
622 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
623 width = 0x7fff;
624 else
b94ed577 625 width = graphic_width - 1;
a171fe39
AZ		 626 mouse_event(mouse_event_opaque,
627 width - dy, dx, dz, buttons_state);
628 } else
629 mouse_event(mouse_event_opaque,
630 dx, dy, dz, buttons_state);
63066f4f
FB		 631 }
632}
633
09b26c5e
FB		 634int kbd_mouse_is_absolute(void)
635{
455204eb
TS		 636 if (!qemu_put_mouse_event_current)
637 return 0;
638
639 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
640}
641
642void do_info_mice(void)
643{
644 QEMUPutMouseEntry *cursor;
645 int index = 0;
646
647 if (!qemu_put_mouse_event_head) {
648 term_printf("No mouse devices connected\n");
649 return;
650 }
651
652 term_printf("Mouse devices available:\n");
653 cursor = qemu_put_mouse_event_head;
654 while (cursor != NULL) {
655 term_printf("%c Mouse #%d: %s\n",
656 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
657 index, cursor->qemu_put_mouse_event_name);
658 index++;
659 cursor = cursor->next;
660 }
661}
662
663void do_mouse_set(int index)
664{
665 QEMUPutMouseEntry *cursor;
666 int i = 0;
667
668 if (!qemu_put_mouse_event_head) {
669 term_printf("No mouse devices connected\n");
670 return;
671 }
672
673 cursor = qemu_put_mouse_event_head;
674 while (cursor != NULL && index != i) {
675 i++;
676 cursor = cursor->next;
677 }
678
679 if (cursor != NULL)
680 qemu_put_mouse_event_current = cursor;
681 else
682 term_printf("Mouse at given index not found\n");
09b26c5e
FB		 683}
684
1dce7c3c
FB		 685/* compute with 96 bit intermediate result: (a*b)/c */
686uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
0824d6fc 687{
1dce7c3c
FB		 688 union {
689 uint64_t ll;
690 struct {
691#ifdef WORDS_BIGENDIAN
692 uint32_t high, low;
693#else
694 uint32_t low, high;
3b46e624 695#endif
1dce7c3c
FB		 696 } l;
697 } u, res;
698 uint64_t rl, rh;
0824d6fc 699
1dce7c3c
FB		 700 u.ll = a;
701 rl = (uint64_t)u.l.low * (uint64_t)b;
702 rh = (uint64_t)u.l.high * (uint64_t)b;
703 rh += (rl >> 32);
704 res.l.high = rh / c;
705 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
706 return res.ll;
34865134
FB		 707}
708
1dce7c3c
FB		 709/***********************************************************/
710/* real time host monotonic timer */
34865134 711
1dce7c3c 712#define QEMU_TIMER_BASE 1000000000LL
34865134 713
1dce7c3c 714#ifdef WIN32
0824d6fc 715
1dce7c3c 716static int64_t clock_freq;
1115dde7 717
1dce7c3c 718static void init_get_clock(void)
1115dde7 719{
a8e5ac33
FB		 720 LARGE_INTEGER freq;
721 int ret;
1dce7c3c
FB		 722 ret = QueryPerformanceFrequency(&freq);
723 if (ret == 0) {
724 fprintf(stderr, "Could not calibrate ticks\n");
725 exit(1);
726 }
727 clock_freq = freq.QuadPart;
1115dde7
FB		 728}
729
1dce7c3c 730static int64_t get_clock(void)
b8076a74 731{
1dce7c3c
FB		 732 LARGE_INTEGER ti;
733 QueryPerformanceCounter(&ti);
734 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
b8076a74
FB		 735}
736
1dce7c3c 737#else
90cb9493 738
1dce7c3c
FB		 739static int use_rt_clock;
740
741static void init_get_clock(void)
90cb9493 742{
1dce7c3c
FB		 743 use_rt_clock = 0;
744#if defined(__linux__)
745 {
746 struct timespec ts;
747 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
748 use_rt_clock = 1;
749 }
750 }
751#endif
90cb9493
FB		 752}
753
1dce7c3c 754static int64_t get_clock(void)
fdbb4691 755{
1dce7c3c
FB		 756#if defined(__linux__)
757 if (use_rt_clock) {
758 struct timespec ts;
759 clock_gettime(CLOCK_MONOTONIC, &ts);
760 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
5fafdf24 761 } else
fdbb4691 762#endif
1dce7c3c
FB		 763 {
764 /* XXX: using gettimeofday leads to problems if the date
765 changes, so it should be avoided. */
766 struct timeval tv;
767 gettimeofday(&tv, NULL);
768 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
769 }
fdbb4691 770}
34865134
FB		 771#endif
772
2e70f6ef
PB		 773/* Return the virtual CPU time, based on the instruction counter. */
774static int64_t cpu_get_icount(void)
775{
776 int64_t icount;
777 CPUState *env = cpu_single_env;;
778 icount = qemu_icount;
779 if (env) {
780 if (!can_do_io(env))
781 fprintf(stderr, "Bad clock read\n");
782 icount -= (env->icount_decr.u16.low + env->icount_extra);
783 }
784 return qemu_icount_bias + (icount << icount_time_shift);
785}
786
1dce7c3c
FB		 787/***********************************************************/
788/* guest cycle counter */
789
eade0f19 790static int64_t cpu_ticks_prev;
34865134 791static int64_t cpu_ticks_offset;
1dce7c3c 792static int64_t cpu_clock_offset;
8a7ddc38 793static int cpu_ticks_enabled;
34865134 794
1dce7c3c
FB		 795/* return the host CPU cycle counter and handle stop/restart */
796int64_t cpu_get_ticks(void)
34865134 797{
2e70f6ef
PB		 798 if (use_icount) {
799 return cpu_get_icount();
800 }
8a7ddc38
FB		 801 if (!cpu_ticks_enabled) {
802 return cpu_ticks_offset;
803 } else {
eade0f19
FB		 804 int64_t ticks;
805 ticks = cpu_get_real_ticks();
806 if (cpu_ticks_prev > ticks) {
807 /* Note: non increasing ticks may happen if the host uses
808 software suspend */
809 cpu_ticks_offset += cpu_ticks_prev - ticks;
810 }
811 cpu_ticks_prev = ticks;
812 return ticks + cpu_ticks_offset;
8a7ddc38 813 }
34865134
FB		 814}
815
1dce7c3c
FB		 816/* return the host CPU monotonic timer and handle stop/restart */
817static int64_t cpu_get_clock(void)
818{
819 int64_t ti;
820 if (!cpu_ticks_enabled) {
821 return cpu_clock_offset;
822 } else {
823 ti = get_clock();
824 return ti + cpu_clock_offset;
825 }
826}
827
34865134
FB		 828/* enable cpu_get_ticks() */
829void cpu_enable_ticks(void)
830{
8a7ddc38
FB		 831 if (!cpu_ticks_enabled) {
832 cpu_ticks_offset -= cpu_get_real_ticks();
1dce7c3c 833 cpu_clock_offset -= get_clock();
8a7ddc38
FB		 834 cpu_ticks_enabled = 1;
835 }
34865134
FB		 836}
837
838/* disable cpu_get_ticks() : the clock is stopped. You must not call
839 cpu_get_ticks() after that. */
840void cpu_disable_ticks(void)
841{
8a7ddc38
FB		 842 if (cpu_ticks_enabled) {
843 cpu_ticks_offset = cpu_get_ticks();
1dce7c3c 844 cpu_clock_offset = cpu_get_clock();
8a7ddc38
FB		 845 cpu_ticks_enabled = 0;
846 }
34865134
FB		 847}
848
1dce7c3c
FB		 849/***********************************************************/
850/* timers */
5fafdf24 851
8a7ddc38
FB		 852#define QEMU_TIMER_REALTIME 0
853#define QEMU_TIMER_VIRTUAL 1
854
855struct QEMUClock {
856 int type;
857 /* XXX: add frequency */
858};
859
860struct QEMUTimer {
861 QEMUClock *clock;
862 int64_t expire_time;
863 QEMUTimerCB *cb;
864 void *opaque;
865 struct QEMUTimer *next;
866};
867
c8994013
TS		 868struct qemu_alarm_timer {
869 char const *name;
efe75411 870 unsigned int flags;
c8994013
TS		 871
872 int (*start)(struct qemu_alarm_timer *t);
873 void (*stop)(struct qemu_alarm_timer *t);
efe75411 874 void (*rearm)(struct qemu_alarm_timer *t);
c8994013
TS		 875 void *priv;
876};
877
efe75411 878#define ALARM_FLAG_DYNTICKS 0x1
d5d08334 879#define ALARM_FLAG_EXPIRED 0x2
efe75411
TS		 880
881static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
882{
883 return t->flags & ALARM_FLAG_DYNTICKS;
884}
885
886static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
887{
888 if (!alarm_has_dynticks(t))
889 return;
890
891 t->rearm(t);
892}
893
894/* TODO: MIN_TIMER_REARM_US should be optimized */
895#define MIN_TIMER_REARM_US 250
896
c8994013 897static struct qemu_alarm_timer *alarm_timer;
8a7ddc38 898
40c3bac3 899#ifdef _WIN32
c8994013
TS		 900
901struct qemu_alarm_win32 {
902 MMRESULT timerId;
903 HANDLE host_alarm;
904 unsigned int period;
905} alarm_win32_data = {0, NULL, -1};
906
907static int win32_start_timer(struct qemu_alarm_timer *t);
908static void win32_stop_timer(struct qemu_alarm_timer *t);
efe75411 909static void win32_rearm_timer(struct qemu_alarm_timer *t);
c8994013 910
40c3bac3 911#else
c8994013
TS		 912
913static int unix_start_timer(struct qemu_alarm_timer *t);
914static void unix_stop_timer(struct qemu_alarm_timer *t);
915
231c6586
TS		 916#ifdef __linux__
917
efe75411
TS		 918static int dynticks_start_timer(struct qemu_alarm_timer *t);
919static void dynticks_stop_timer(struct qemu_alarm_timer *t);
920static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
921
c40ec5a9
TS		 922static int hpet_start_timer(struct qemu_alarm_timer *t);
923static void hpet_stop_timer(struct qemu_alarm_timer *t);
924
c8994013
TS		 925static int rtc_start_timer(struct qemu_alarm_timer *t);
926static void rtc_stop_timer(struct qemu_alarm_timer *t);
927
efe75411 928#endif /* __linux__ */
8a7ddc38 929
c8994013
TS		 930#endif /* _WIN32 */
931
2e70f6ef 932/* Correlation between real and virtual time is always going to be
bf20dc07 933 fairly approximate, so ignore small variation.
2e70f6ef
PB		 934 When the guest is idle real and virtual time will be aligned in
935 the IO wait loop. */
936#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
937
938static void icount_adjust(void)
939{
940 int64_t cur_time;
941 int64_t cur_icount;
942 int64_t delta;
943 static int64_t last_delta;
944 /* If the VM is not running, then do nothing. */
945 if (!vm_running)
946 return;
947
948 cur_time = cpu_get_clock();
949 cur_icount = qemu_get_clock(vm_clock);
950 delta = cur_icount - cur_time;
951 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
952 if (delta > 0
953 && last_delta + ICOUNT_WOBBLE < delta * 2
954 && icount_time_shift > 0) {
955 /* The guest is getting too far ahead. Slow time down. */
956 icount_time_shift--;
957 }
958 if (delta < 0
959 && last_delta - ICOUNT_WOBBLE > delta * 2
960 && icount_time_shift < MAX_ICOUNT_SHIFT) {
961 /* The guest is getting too far behind. Speed time up. */
962 icount_time_shift++;
963 }
964 last_delta = delta;
965 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
966}
967
968static void icount_adjust_rt(void * opaque)
969{
970 qemu_mod_timer(icount_rt_timer,
971 qemu_get_clock(rt_clock) + 1000);
972 icount_adjust();
973}
974
975static void icount_adjust_vm(void * opaque)
976{
977 qemu_mod_timer(icount_vm_timer,
978 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
979 icount_adjust();
980}
981
982static void init_icount_adjust(void)
983{
984 /* Have both realtime and virtual time triggers for speed adjustment.
985 The realtime trigger catches emulated time passing too slowly,
986 the virtual time trigger catches emulated time passing too fast.
987 Realtime triggers occur even when idle, so use them less frequently
988 than VM triggers. */
989 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
990 qemu_mod_timer(icount_rt_timer,
991 qemu_get_clock(rt_clock) + 1000);
992 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
993 qemu_mod_timer(icount_vm_timer,
994 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
995}
996
c8994013 997static struct qemu_alarm_timer alarm_timers[] = {
efe75411 998#ifndef _WIN32
231c6586 999#ifdef __linux__
efe75411
TS		 1000 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1001 dynticks_stop_timer, dynticks_rearm_timer, NULL},
c40ec5a9 1002 /* HPET - if available - is preferred */
efe75411 1003 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
c40ec5a9 1004 /* ...otherwise try RTC */
efe75411 1005 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
c8994013 1006#endif
efe75411 1007 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
c8994013 1008#else
efe75411
TS		 1009 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1010 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1011 {"win32", 0, win32_start_timer,
1012 win32_stop_timer, NULL, &alarm_win32_data},
c8994013
TS		 1013#endif
1014 {NULL, }
1015};
1016
3f47aa8c 1017static void show_available_alarms(void)
f3dcfada
TS		 1018{
1019 int i;
1020
1021 printf("Available alarm timers, in order of precedence:\n");
1022 for (i = 0; alarm_timers[i].name; i++)
1023 printf("%s\n", alarm_timers[i].name);
1024}
1025
1026static void configure_alarms(char const *opt)
1027{
1028 int i;
1029 int cur = 0;
1030 int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1031 char *arg;
1032 char *name;
2e70f6ef 1033 struct qemu_alarm_timer tmp;
f3dcfada 1034
3adda04c 1035 if (!strcmp(opt, "?")) {
f3dcfada
TS		 1036 show_available_alarms();
1037 exit(0);
1038 }
1039
1040 arg = strdup(opt);
1041
1042 /* Reorder the array */
1043 name = strtok(arg, ",");
1044 while (name) {
e2b577e5 1045 for (i = 0; i < count && alarm_timers[i].name; i++) {
f3dcfada
TS		 1046 if (!strcmp(alarm_timers[i].name, name))
1047 break;
1048 }
1049
1050 if (i == count) {
1051 fprintf(stderr, "Unknown clock %s\n", name);
1052 goto next;
1053 }
1054
1055 if (i < cur)
1056 /* Ignore */
1057 goto next;
1058
1059 /* Swap */
1060 tmp = alarm_timers[i];
1061 alarm_timers[i] = alarm_timers[cur];
1062 alarm_timers[cur] = tmp;
1063
1064 cur++;
1065next:
1066 name = strtok(NULL, ",");
1067 }
1068
1069 free(arg);
1070
1071 if (cur) {
2e70f6ef 1072 /* Disable remaining timers */
f3dcfada
TS		 1073 for (i = cur; i < count; i++)
1074 alarm_timers[i].name = NULL;
3adda04c
AJ		 1075 } else {
1076 show_available_alarms();
1077 exit(1);
f3dcfada 1078 }
f3dcfada
TS		 1079}
1080
c8994013
TS		 1081QEMUClock *rt_clock;
1082QEMUClock *vm_clock;
1083
1084static QEMUTimer *active_timers[2];
1085
9596ebb7 1086static QEMUClock *qemu_new_clock(int type)
8a7ddc38
FB		 1087{
1088 QEMUClock *clock;
1089 clock = qemu_mallocz(sizeof(QEMUClock));
1090 if (!clock)
1091 return NULL;
1092 clock->type = type;
1093 return clock;
1094}
1095
1096QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1097{
1098 QEMUTimer *ts;
1099
1100 ts = qemu_mallocz(sizeof(QEMUTimer));
1101 ts->clock = clock;
1102 ts->cb = cb;
1103 ts->opaque = opaque;
1104 return ts;
1105}
1106
1107void qemu_free_timer(QEMUTimer *ts)
1108{
1109 qemu_free(ts);
1110}
1111
1112/* stop a timer, but do not dealloc it */
1113void qemu_del_timer(QEMUTimer *ts)
1114{
1115 QEMUTimer **pt, *t;
1116
1117 /* NOTE: this code must be signal safe because
1118 qemu_timer_expired() can be called from a signal. */
1119 pt = &active_timers[ts->clock->type];
1120 for(;;) {
1121 t = *pt;
1122 if (!t)
1123 break;
1124 if (t == ts) {
1125 *pt = t->next;
1126 break;
1127 }
1128 pt = &t->next;
1129 }
1130}
1131
1132/* modify the current timer so that it will be fired when current_time
1133 >= expire_time. The corresponding callback will be called. */
1134void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1135{
1136 QEMUTimer **pt, *t;
1137
1138 qemu_del_timer(ts);
1139
1140 /* add the timer in the sorted list */
1141 /* NOTE: this code must be signal safe because
1142 qemu_timer_expired() can be called from a signal. */
1143 pt = &active_timers[ts->clock->type];
1144 for(;;) {
1145 t = *pt;
1146 if (!t)
1147 break;
5fafdf24 1148 if (t->expire_time > expire_time)
8a7ddc38
FB		 1149 break;
1150 pt = &t->next;
1151 }
1152 ts->expire_time = expire_time;
1153 ts->next = *pt;
1154 *pt = ts;
d5d08334
AZ		 1155
1156 /* Rearm if necessary */
2e70f6ef
PB		 1157 if (pt == &active_timers[ts->clock->type]) {
1158 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1159 qemu_rearm_alarm_timer(alarm_timer);
1160 }
1161 /* Interrupt execution to force deadline recalculation. */
1162 if (use_icount && cpu_single_env) {
1163 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1164 }
1165 }
8a7ddc38
FB		 1166}
1167
1168int qemu_timer_pending(QEMUTimer *ts)
1169{
1170 QEMUTimer *t;
1171 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1172 if (t == ts)
1173 return 1;
1174 }
1175 return 0;
1176}
1177
1178static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1179{
1180 if (!timer_head)
1181 return 0;
1182 return (timer_head->expire_time <= current_time);
1183}
1184
1185static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1186{
1187 QEMUTimer *ts;
3b46e624 1188
8a7ddc38
FB		 1189 for(;;) {
1190 ts = *ptimer_head;
e95c8d51 1191 if (!ts || ts->expire_time > current_time)
8a7ddc38
FB		 1192 break;
1193 /* remove timer from the list before calling the callback */
1194 *ptimer_head = ts->next;
1195 ts->next = NULL;
3b46e624 1196
8a7ddc38
FB		 1197 /* run the callback (the timer list can be modified) */
1198 ts->cb(ts->opaque);
1199 }
1200}
1201
1202int64_t qemu_get_clock(QEMUClock *clock)
1203{
1204 switch(clock->type) {
1205 case QEMU_TIMER_REALTIME:
1dce7c3c 1206 return get_clock() / 1000000;
8a7ddc38
FB		 1207 default:
1208 case QEMU_TIMER_VIRTUAL:
2e70f6ef
PB		 1209 if (use_icount) {
1210 return cpu_get_icount();
1211 } else {
1212 return cpu_get_clock();
1213 }
8a7ddc38
FB		 1214 }
1215}
1216
1dce7c3c
FB		 1217static void init_timers(void)
1218{
1219 init_get_clock();
1220 ticks_per_sec = QEMU_TIMER_BASE;
1221 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1222 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1223}
1224
8a7ddc38
FB		 1225/* save a timer */
1226void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1227{
1228 uint64_t expire_time;
1229
1230 if (qemu_timer_pending(ts)) {
1231 expire_time = ts->expire_time;
1232 } else {
1233 expire_time = -1;
1234 }
1235 qemu_put_be64(f, expire_time);
1236}
1237
1238void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1239{
1240 uint64_t expire_time;
1241
1242 expire_time = qemu_get_be64(f);
1243 if (expire_time != -1) {
1244 qemu_mod_timer(ts, expire_time);
1245 } else {
1246 qemu_del_timer(ts);
1247 }
1248}
1249
1250static void timer_save(QEMUFile *f, void *opaque)
1251{
1252 if (cpu_ticks_enabled) {
1253 hw_error("cannot save state if virtual timers are running");
1254 }
bee8d684
TS		 1255 qemu_put_be64(f, cpu_ticks_offset);
1256 qemu_put_be64(f, ticks_per_sec);
1257 qemu_put_be64(f, cpu_clock_offset);
8a7ddc38
FB		 1258}
1259
1260static int timer_load(QEMUFile *f, void *opaque, int version_id)
1261{
c88676f8 1262 if (version_id != 1 && version_id != 2)
8a7ddc38
FB		 1263 return -EINVAL;
1264 if (cpu_ticks_enabled) {
1265 return -EINVAL;
1266 }
bee8d684
TS		 1267 cpu_ticks_offset=qemu_get_be64(f);
1268 ticks_per_sec=qemu_get_be64(f);
c88676f8 1269 if (version_id == 2) {
bee8d684 1270 cpu_clock_offset=qemu_get_be64(f);
c88676f8 1271 }
8a7ddc38
FB		 1272 return 0;
1273}
1274
67b915a5 1275#ifdef _WIN32
5fafdf24 1276void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
67b915a5
FB		 1277 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1278#else
8a7ddc38 1279static void host_alarm_handler(int host_signum)
67b915a5 1280#endif
8a7ddc38 1281{
02ba45c5
FB		 1282#if 0
1283#define DISP_FREQ 1000
1284 {
1285 static int64_t delta_min = INT64_MAX;
1286 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1287 static int count;
1288 ti = qemu_get_clock(vm_clock);
1289 if (last_clock != 0) {
1290 delta = ti - last_clock;
1291 if (delta < delta_min)
1292 delta_min = delta;
1293 if (delta > delta_max)
1294 delta_max = delta;
1295 delta_cum += delta;
1296 if (++count == DISP_FREQ) {
26a76461 1297 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
02ba45c5
FB		 1298 muldiv64(delta_min, 1000000, ticks_per_sec),
1299 muldiv64(delta_max, 1000000, ticks_per_sec),
1300 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1301 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1302 count = 0;
1303 delta_min = INT64_MAX;
1304 delta_max = 0;
1305 delta_cum = 0;
1306 }
1307 }
1308 last_clock = ti;
1309 }
1310#endif
efe75411 1311 if (alarm_has_dynticks(alarm_timer) ||
2e70f6ef
PB		 1312 (!use_icount &&
1313 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1314 qemu_get_clock(vm_clock))) ||
8a7ddc38
FB		 1315 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1316 qemu_get_clock(rt_clock))) {
06d9f2f7 1317#ifdef _WIN32
c8994013
TS		 1318 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1319 SetEvent(data->host_alarm);
06d9f2f7 1320#endif
ee5605e5
AZ		 1321 CPUState *env = next_cpu;
1322
d5d08334
AZ		 1323 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1324
4f8eb8da
AZ		 1325 if (env) {
1326 /* stop the currently executing cpu because a timer occured */
1327 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
a332e112 1328#ifdef USE_KQEMU
4f8eb8da
AZ		 1329 if (env->kqemu_enabled) {
1330 kqemu_cpu_interrupt(env);
1331 }
ee5605e5 1332#endif
4f8eb8da 1333 }
ee5605e5 1334 event_pending = 1;
8a7ddc38
FB		 1335 }
1336}
1337
2e70f6ef 1338static int64_t qemu_next_deadline(void)
efe75411 1339{
2e70f6ef 1340 int64_t delta;
efe75411
TS		 1341
1342 if (active_timers[QEMU_TIMER_VIRTUAL]) {
2e70f6ef
PB		 1343 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1344 qemu_get_clock(vm_clock);
1345 } else {
1346 /* To avoid problems with overflow limit this to 2^32. */
1347 delta = INT32_MAX;
efe75411
TS		 1348 }
1349
2e70f6ef
PB		 1350 if (delta < 0)
1351 delta = 0;
efe75411 1352
2e70f6ef
PB		 1353 return delta;
1354}
1355
8632fb9a 1356#if defined(__linux__) || defined(_WIN32)
2e70f6ef
PB		 1357static uint64_t qemu_next_deadline_dyntick(void)
1358{
1359 int64_t delta;
1360 int64_t rtdelta;
1361
1362 if (use_icount)
1363 delta = INT32_MAX;
1364 else
1365 delta = (qemu_next_deadline() + 999) / 1000;
1366
1367 if (active_timers[QEMU_TIMER_REALTIME]) {
1368 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1369 qemu_get_clock(rt_clock))*1000;
1370 if (rtdelta < delta)
1371 delta = rtdelta;
1372 }
1373
1374 if (delta < MIN_TIMER_REARM_US)
1375 delta = MIN_TIMER_REARM_US;
1376
1377 return delta;
efe75411 1378}
8632fb9a 1379#endif
efe75411 1380
fd872598
FB		 1381#ifndef _WIN32
1382
829309c7
FB		 1383#if defined(__linux__)
1384
fd872598
FB		 1385#define RTC_FREQ 1024
1386
c8994013
TS		 1387static void enable_sigio_timer(int fd)
1388{
1389 struct sigaction act;
1390
1391 /* timer signal */
1392 sigfillset(&act.sa_mask);
1393 act.sa_flags = 0;
c8994013
TS		 1394 act.sa_handler = host_alarm_handler;
1395
1396 sigaction(SIGIO, &act, NULL);
1397 fcntl(fd, F_SETFL, O_ASYNC);
1398 fcntl(fd, F_SETOWN, getpid());
1399}
829309c7 1400
c40ec5a9
TS		 1401static int hpet_start_timer(struct qemu_alarm_timer *t)
1402{
1403 struct hpet_info info;
1404 int r, fd;
1405
1406 fd = open("/dev/hpet", O_RDONLY);
1407 if (fd < 0)
1408 return -1;
1409
1410 /* Set frequency */
1411 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1412 if (r < 0) {
1413 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1414 "error, but for better emulation accuracy type:\n"
1415 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1416 goto fail;
1417 }
1418
1419 /* Check capabilities */
1420 r = ioctl(fd, HPET_INFO, &info);
1421 if (r < 0)
1422 goto fail;
1423
1424 /* Enable periodic mode */
1425 r = ioctl(fd, HPET_EPI, 0);
1426 if (info.hi_flags && (r < 0))
1427 goto fail;
1428
1429 /* Enable interrupt */
1430 r = ioctl(fd, HPET_IE_ON, 0);
1431 if (r < 0)
1432 goto fail;
1433
1434 enable_sigio_timer(fd);
fcdc2129 1435 t->priv = (void *)(long)fd;
c40ec5a9
TS		 1436
1437 return 0;
1438fail:
1439 close(fd);
1440 return -1;
1441}
1442
1443static void hpet_stop_timer(struct qemu_alarm_timer *t)
1444{
fcdc2129 1445 int fd = (long)t->priv;
c40ec5a9
TS		 1446
1447 close(fd);
1448}
1449
c8994013 1450static int rtc_start_timer(struct qemu_alarm_timer *t)
fd872598 1451{
c8994013 1452 int rtc_fd;
b5a23ad4 1453 unsigned long current_rtc_freq = 0;
c8994013 1454
aeb30be6 1455 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
fd872598
FB		 1456 if (rtc_fd < 0)
1457 return -1;
b5a23ad4
AZ		 1458 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1459 if (current_rtc_freq != RTC_FREQ &&
1460 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
fd872598
FB		 1461 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1462 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1463 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1464 goto fail;
1465 }
1466 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1467 fail:
1468 close(rtc_fd);
1469 return -1;
1470 }
c8994013
TS		 1471
1472 enable_sigio_timer(rtc_fd);
1473
fcdc2129 1474 t->priv = (void *)(long)rtc_fd;
c8994013 1475
fd872598
FB		 1476 return 0;
1477}
1478
c8994013 1479static void rtc_stop_timer(struct qemu_alarm_timer *t)
829309c7 1480{
fcdc2129 1481 int rtc_fd = (long)t->priv;
c8994013
TS		 1482
1483 close(rtc_fd);
829309c7
FB		 1484}
1485
efe75411
TS		 1486static int dynticks_start_timer(struct qemu_alarm_timer *t)
1487{
1488 struct sigevent ev;
1489 timer_t host_timer;
1490 struct sigaction act;
1491
1492 sigfillset(&act.sa_mask);
1493 act.sa_flags = 0;
efe75411
TS		 1494 act.sa_handler = host_alarm_handler;
1495
1496 sigaction(SIGALRM, &act, NULL);
1497
1498 ev.sigev_value.sival_int = 0;
1499 ev.sigev_notify = SIGEV_SIGNAL;
1500 ev.sigev_signo = SIGALRM;
1501
1502 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1503 perror("timer_create");
1504
1505 /* disable dynticks */
1506 fprintf(stderr, "Dynamic Ticks disabled\n");
1507
1508 return -1;
1509 }
1510
1511 t->priv = (void *)host_timer;
1512
1513 return 0;
1514}
1515
1516static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1517{
1518 timer_t host_timer = (timer_t)t->priv;
1519
1520 timer_delete(host_timer);
1521}
1522
1523static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1524{
1525 timer_t host_timer = (timer_t)t->priv;
1526 struct itimerspec timeout;
1527 int64_t nearest_delta_us = INT64_MAX;
1528 int64_t current_us;
1529
1530 if (!active_timers[QEMU_TIMER_REALTIME] &&
1531 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1532 return;
efe75411 1533
2e70f6ef 1534 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1535
1536 /* check whether a timer is already running */
1537 if (timer_gettime(host_timer, &timeout)) {
1538 perror("gettime");
1539 fprintf(stderr, "Internal timer error: aborting\n");
1540 exit(1);
1541 }
1542 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1543 if (current_us && current_us <= nearest_delta_us)
1544 return;
1545
1546 timeout.it_interval.tv_sec = 0;
1547 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1548 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1549 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1550 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1551 perror("settime");
1552 fprintf(stderr, "Internal timer error: aborting\n");
1553 exit(1);
1554 }
1555}
1556
70744b3a 1557#endif /* defined(__linux__) */
231c6586 1558
c8994013
TS		 1559static int unix_start_timer(struct qemu_alarm_timer *t)
1560{
1561 struct sigaction act;
1562 struct itimerval itv;
1563 int err;
1564
1565 /* timer signal */
1566 sigfillset(&act.sa_mask);
1567 act.sa_flags = 0;
c8994013
TS		 1568 act.sa_handler = host_alarm_handler;
1569
1570 sigaction(SIGALRM, &act, NULL);
1571
1572 itv.it_interval.tv_sec = 0;
1573 /* for i386 kernel 2.6 to get 1 ms */
1574 itv.it_interval.tv_usec = 999;
1575 itv.it_value.tv_sec = 0;
1576 itv.it_value.tv_usec = 10 * 1000;
1577
1578 err = setitimer(ITIMER_REAL, &itv, NULL);
1579 if (err)
1580 return -1;
1581
1582 return 0;
1583}
1584
1585static void unix_stop_timer(struct qemu_alarm_timer *t)
1586{
1587 struct itimerval itv;
1588
1589 memset(&itv, 0, sizeof(itv));
1590 setitimer(ITIMER_REAL, &itv, NULL);
1591}
1592
829309c7 1593#endif /* !defined(_WIN32) */
fd872598 1594
c8994013
TS		 1595#ifdef _WIN32
1596
1597static int win32_start_timer(struct qemu_alarm_timer *t)
1598{
1599 TIMECAPS tc;
1600 struct qemu_alarm_win32 *data = t->priv;
efe75411 1601 UINT flags;
c8994013
TS		 1602
1603 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1604 if (!data->host_alarm) {
1605 perror("Failed CreateEvent");
c396a7f0 1606 return -1;
c8994013
TS		 1607 }
1608
1609 memset(&tc, 0, sizeof(tc));
1610 timeGetDevCaps(&tc, sizeof(tc));
1611
1612 if (data->period < tc.wPeriodMin)
1613 data->period = tc.wPeriodMin;
1614
1615 timeBeginPeriod(data->period);
1616
efe75411
TS		 1617 flags = TIME_CALLBACK_FUNCTION;
1618 if (alarm_has_dynticks(t))
1619 flags |= TIME_ONESHOT;
1620 else
1621 flags |= TIME_PERIODIC;
1622
c8994013
TS		 1623 data->timerId = timeSetEvent(1, // interval (ms)
1624 data->period, // resolution
1625 host_alarm_handler, // function
1626 (DWORD)t, // parameter
efe75411 1627 flags);
c8994013
TS		 1628
1629 if (!data->timerId) {
1630 perror("Failed to initialize win32 alarm timer");
1631
1632 timeEndPeriod(data->period);
1633 CloseHandle(data->host_alarm);
1634 return -1;
1635 }
1636
1637 qemu_add_wait_object(data->host_alarm, NULL, NULL);
1638
1639 return 0;
1640}
1641
1642static void win32_stop_timer(struct qemu_alarm_timer *t)
1643{
1644 struct qemu_alarm_win32 *data = t->priv;
1645
1646 timeKillEvent(data->timerId);
1647 timeEndPeriod(data->period);
1648
1649 CloseHandle(data->host_alarm);
1650}
1651
efe75411
TS		 1652static void win32_rearm_timer(struct qemu_alarm_timer *t)
1653{
1654 struct qemu_alarm_win32 *data = t->priv;
1655 uint64_t nearest_delta_us;
1656
1657 if (!active_timers[QEMU_TIMER_REALTIME] &&
1658 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1659 return;
efe75411 1660
2e70f6ef 1661 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1662 nearest_delta_us /= 1000;
1663
1664 timeKillEvent(data->timerId);
1665
1666 data->timerId = timeSetEvent(1,
1667 data->period,
1668 host_alarm_handler,
1669 (DWORD)t,
1670 TIME_ONESHOT | TIME_PERIODIC);
1671
1672 if (!data->timerId) {
1673 perror("Failed to re-arm win32 alarm timer");
1674
1675 timeEndPeriod(data->period);
1676 CloseHandle(data->host_alarm);
1677 exit(1);
1678 }
1679}
1680
c8994013
TS		 1681#endif /* _WIN32 */
1682
1dce7c3c 1683static void init_timer_alarm(void)
8a7ddc38 1684{
223f0d72 1685 struct qemu_alarm_timer *t = NULL;
c8994013
TS		 1686 int i, err = -1;
1687
1688 for (i = 0; alarm_timers[i].name; i++) {
1689 t = &alarm_timers[i];
1690
c8994013
TS		 1691 err = t->start(t);
1692 if (!err)
1693 break;
67b915a5 1694 }
fd872598 1695
c8994013
TS		 1696 if (err) {
1697 fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1698 fprintf(stderr, "Terminating\n");
1699 exit(1);
67b915a5 1700 }
c8994013
TS		 1701
1702 alarm_timer = t;
8a7ddc38
FB		 1703}
1704
9596ebb7 1705static void quit_timers(void)
40c3bac3 1706{
c8994013
TS		 1707 alarm_timer->stop(alarm_timer);
1708 alarm_timer = NULL;
40c3bac3
FB		 1709}
1710
f6503059
AZ		 1711/***********************************************************/
1712/* host time/date access */
1713void qemu_get_timedate(struct tm *tm, int offset)
1714{
1715 time_t ti;
1716 struct tm *ret;
1717
1718 time(&ti);
1719 ti += offset;
1720 if (rtc_date_offset == -1) {
1721 if (rtc_utc)
1722 ret = gmtime(&ti);
1723 else
1724 ret = localtime(&ti);
1725 } else {
1726 ti -= rtc_date_offset;
1727 ret = gmtime(&ti);
1728 }
1729
1730 memcpy(tm, ret, sizeof(struct tm));
1731}
1732
1733int qemu_timedate_diff(struct tm *tm)
1734{
1735 time_t seconds;
1736
1737 if (rtc_date_offset == -1)
1738 if (rtc_utc)
1739 seconds = mktimegm(tm);
1740 else
1741 seconds = mktime(tm);
1742 else
1743 seconds = mktimegm(tm) + rtc_date_offset;
1744
1745 return seconds - time(NULL);
1746}
1747
c4b1fcc0 1748/***********************************************************/
82c643ff 1749/* character device */
313aa567 1750
e5b0bc44
PB		 1751static void qemu_chr_event(CharDriverState *s, int event)
1752{
1753 if (!s->chr_event)
1754 return;
1755 s->chr_event(s->handler_opaque, event);
1756}
1757
86e94dea
TS		 1758static void qemu_chr_reset_bh(void *opaque)
1759{
1760 CharDriverState *s = opaque;
e5b0bc44 1761 qemu_chr_event(s, CHR_EVENT_RESET);
86e94dea
TS		 1762 qemu_bh_delete(s->bh);
1763 s->bh = NULL;
1764}
1765
1766void qemu_chr_reset(CharDriverState *s)
1767{
1768 if (s->bh == NULL) {
1769 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1770 qemu_bh_schedule(s->bh);
1771 }
1772}
1773
82c643ff
FB		 1774int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1775{
1776 return s->chr_write(s, buf, len);
1777}
67b915a5 1778
e57a8c0e 1779int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
f8d179e3 1780{
e57a8c0e
FB		 1781 if (!s->chr_ioctl)
1782 return -ENOTSUP;
1783 return s->chr_ioctl(s, cmd, arg);
f8d179e3
FB		 1784}
1785
e5b0bc44
PB		 1786int qemu_chr_can_read(CharDriverState *s)
1787{
1788 if (!s->chr_can_read)
1789 return 0;
1790 return s->chr_can_read(s->handler_opaque);
1791}
1792
1793void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1794{
1795 s->chr_read(s->handler_opaque, buf, len);
1796}
1797
bd9bdce6
AZ		 1798void qemu_chr_accept_input(CharDriverState *s)
1799{
1800 if (s->chr_accept_input)
1801 s->chr_accept_input(s);
1802}
e5b0bc44 1803
82c643ff 1804void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
67b915a5 1805{
82c643ff
FB		 1806 char buf[4096];
1807 va_list ap;
1808 va_start(ap, fmt);
1809 vsnprintf(buf, sizeof(buf), fmt, ap);
ffe8ab83 1810 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
82c643ff 1811 va_end(ap);
67b915a5
FB		 1812}
1813
5905b2e5
FB		 1814void qemu_chr_send_event(CharDriverState *s, int event)
1815{
1816 if (s->chr_send_event)
1817 s->chr_send_event(s, event);
1818}
1819
5fafdf24
TS		 1820void qemu_chr_add_handlers(CharDriverState *s,
1821 IOCanRWHandler *fd_can_read,
e5b0bc44
PB		 1822 IOReadHandler *fd_read,
1823 IOEventHandler *fd_event,
1824 void *opaque)
82c643ff 1825{
e5b0bc44
PB		 1826 s->chr_can_read = fd_can_read;
1827 s->chr_read = fd_read;
1828 s->chr_event = fd_event;
1829 s->handler_opaque = opaque;
1830 if (s->chr_update_read_handler)
1831 s->chr_update_read_handler(s);
82c643ff 1832}
3b46e624 1833
82c643ff 1834static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
313aa567 1835{
82c643ff
FB		 1836 return len;
1837}
1838
52f61fde 1839static CharDriverState *qemu_chr_open_null(void)
82c643ff
FB		 1840{
1841 CharDriverState *chr;
1842
1843 chr = qemu_mallocz(sizeof(CharDriverState));
1844 if (!chr)
1845 return NULL;
1846 chr->chr_write = null_chr_write;
82c643ff
FB		 1847 return chr;
1848}
1849
20d8a3ed
TS		 1850/* MUX driver for serial I/O splitting */
1851static int term_timestamps;
1852static int64_t term_timestamps_start;
9c1de612 1853#define MAX_MUX 4
bd9bdce6
AZ		 1854#define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1855#define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
20d8a3ed
TS		 1856typedef struct {
1857 IOCanRWHandler *chr_can_read[MAX_MUX];
1858 IOReadHandler *chr_read[MAX_MUX];
1859 IOEventHandler *chr_event[MAX_MUX];
1860 void *ext_opaque[MAX_MUX];
1861 CharDriverState *drv;
bd9bdce6
AZ		 1862 unsigned char buffer[MUX_BUFFER_SIZE];
1863 int prod;
1864 int cons;
20d8a3ed
TS		 1865 int mux_cnt;
1866 int term_got_escape;
1867 int max_size;
1868} MuxDriver;
1869
1870
1871static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1872{
1873 MuxDriver *d = chr->opaque;
1874 int ret;
1875 if (!term_timestamps) {
1876 ret = d->drv->chr_write(d->drv, buf, len);
1877 } else {
1878 int i;
1879
1880 ret = 0;
1881 for(i = 0; i < len; i++) {
1882 ret += d->drv->chr_write(d->drv, buf+i, 1);
1883 if (buf[i] == '\n') {
1884 char buf1[64];
1885 int64_t ti;
1886 int secs;
1887
1888 ti = get_clock();
1889 if (term_timestamps_start == -1)
1890 term_timestamps_start = ti;
1891 ti -= term_timestamps_start;
1892 secs = ti / 1000000000;
1893 snprintf(buf1, sizeof(buf1),
1894 "[%02d:%02d:%02d.%03d] ",
1895 secs / 3600,
1896 (secs / 60) % 60,
1897 secs % 60,
1898 (int)((ti / 1000000) % 1000));
ffe8ab83 1899 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
20d8a3ed
TS		 1900 }
1901 }
1902 }
1903 return ret;
1904}
1905
7ccfb2eb 1906static const char * const mux_help[] = {
20d8a3ed
TS		 1907 "% h print this help\n\r",
1908 "% x exit emulator\n\r",
1909 "% s save disk data back to file (if -snapshot)\n\r",
1910 "% t toggle console timestamps\n\r"
1911 "% b send break (magic sysrq)\n\r",
1912 "% c switch between console and monitor\n\r",
1913 "% % sends %\n\r",
1914 NULL
1915};
1916
1917static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1918static void mux_print_help(CharDriverState *chr)
1919{
1920 int i, j;
1921 char ebuf[15] = "Escape-Char";
1922 char cbuf[50] = "\n\r";
1923
1924 if (term_escape_char > 0 && term_escape_char < 26) {
363a37d5
BS		 1925 snprintf(cbuf, sizeof(cbuf), "\n\r");
1926 snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
20d8a3ed 1927 } else {
363a37d5
BS		 1928 snprintf(cbuf, sizeof(cbuf),
1929 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1930 term_escape_char);
20d8a3ed 1931 }
ffe8ab83 1932 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
20d8a3ed
TS		 1933 for (i = 0; mux_help[i] != NULL; i++) {
1934 for (j=0; mux_help[i][j] != '\0'; j++) {
1935 if (mux_help[i][j] == '%')
ffe8ab83 1936 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
20d8a3ed 1937 else
ffe8ab83 1938 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
20d8a3ed
TS		 1939 }
1940 }
1941}
1942
1943static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1944{
1945 if (d->term_got_escape) {
1946 d->term_got_escape = 0;
1947 if (ch == term_escape_char)
1948 goto send_char;
1949 switch(ch) {
1950 case '?':
1951 case 'h':
1952 mux_print_help(chr);
1953 break;
1954 case 'x':
1955 {
7ccfb2eb 1956 const char *term = "QEMU: Terminated\n\r";
ffe8ab83 1957 chr->chr_write(chr,(uint8_t *)term,strlen(term));
20d8a3ed
TS		 1958 exit(0);
1959 break;
1960 }
1961 case 's':
1962 {
1963 int i;
e4bcb14c
TS		 1964 for (i = 0; i < nb_drives; i++) {
1965 bdrv_commit(drives_table[i].bdrv);
20d8a3ed
TS		 1966 }
1967 }
1968 break;
1969 case 'b':
36ddb83b 1970 qemu_chr_event(chr, CHR_EVENT_BREAK);
20d8a3ed
TS		 1971 break;
1972 case 'c':
1973 /* Switch to the next registered device */
1974 chr->focus++;
1975 if (chr->focus >= d->mux_cnt)
1976 chr->focus = 0;
1977 break;
1978 case 't':
1979 term_timestamps = !term_timestamps;
1980 term_timestamps_start = -1;
1981 break;
1982 }
1983 } else if (ch == term_escape_char) {
1984 d->term_got_escape = 1;
1985 } else {
1986 send_char:
1987 return 1;
1988 }
1989 return 0;
1990}
1991
bd9bdce6
AZ		 1992static void mux_chr_accept_input(CharDriverState *chr)
1993{
1994 int m = chr->focus;
1995 MuxDriver *d = chr->opaque;
1996
1997 while (d->prod != d->cons &&
1998 d->chr_can_read[m] &&
1999 d->chr_can_read[m](d->ext_opaque[m])) {
2000 d->chr_read[m](d->ext_opaque[m],
2001 &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
2002 }
2003}
2004
20d8a3ed
TS		 2005static int mux_chr_can_read(void *opaque)
2006{
2007 CharDriverState *chr = opaque;
2008 MuxDriver *d = chr->opaque;
bd9bdce6
AZ		 2009
2010 if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
2011 return 1;
20d8a3ed 2012 if (d->chr_can_read[chr->focus])
bd9bdce6 2013 return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
20d8a3ed
TS		 2014 return 0;
2015}
2016
2017static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
2018{
2019 CharDriverState *chr = opaque;
2020 MuxDriver *d = chr->opaque;
bd9bdce6 2021 int m = chr->focus;
20d8a3ed 2022 int i;
bd9bdce6
AZ		 2023
2024 mux_chr_accept_input (opaque);
2025
20d8a3ed 2026 for(i = 0; i < size; i++)
bd9bdce6
AZ		 2027 if (mux_proc_byte(chr, d, buf[i])) {
2028 if (d->prod == d->cons &&
2029 d->chr_can_read[m] &&
2030 d->chr_can_read[m](d->ext_opaque[m]))
2031 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
2032 else
2033 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
2034 }
20d8a3ed
TS		 2035}
2036
2037static void mux_chr_event(void *opaque, int event)
2038{
2039 CharDriverState *chr = opaque;
2040 MuxDriver *d = chr->opaque;
2041 int i;
2042
2043 /* Send the event to all registered listeners */
2044 for (i = 0; i < d->mux_cnt; i++)
2045 if (d->chr_event[i])
2046 d->chr_event[i](d->ext_opaque[i], event);
2047}
2048
2049static void mux_chr_update_read_handler(CharDriverState *chr)
2050{
2051 MuxDriver *d = chr->opaque;
2052
2053 if (d->mux_cnt >= MAX_MUX) {
2054 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
2055 return;
2056 }
2057 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
2058 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
2059 d->chr_read[d->mux_cnt] = chr->chr_read;
2060 d->chr_event[d->mux_cnt] = chr->chr_event;
2061 /* Fix up the real driver with mux routines */
2062 if (d->mux_cnt == 0) {
2063 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
2064 mux_chr_event, chr);
2065 }
2066 chr->focus = d->mux_cnt;
2067 d->mux_cnt++;
2068}
2069
9596ebb7 2070static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
20d8a3ed
TS		 2071{
2072 CharDriverState *chr;
2073 MuxDriver *d;
2074
2075 chr = qemu_mallocz(sizeof(CharDriverState));
2076 if (!chr)
2077 return NULL;
2078 d = qemu_mallocz(sizeof(MuxDriver));
2079 if (!d) {
2080 free(chr);
2081 return NULL;
2082 }
2083
2084 chr->opaque = d;
2085 d->drv = drv;
2086 chr->focus = -1;
2087 chr->chr_write = mux_chr_write;
2088 chr->chr_update_read_handler = mux_chr_update_read_handler;
bd9bdce6 2089 chr->chr_accept_input = mux_chr_accept_input;
20d8a3ed
TS		 2090 return chr;
2091}
2092
2093
fd1dff4b 2094#ifdef _WIN32
82c643ff 2095
fd1dff4b
FB		 2096static void socket_cleanup(void)
2097{
2098 WSACleanup();
2099}
82c643ff 2100
fd1dff4b
FB		 2101static int socket_init(void)
2102{
2103 WSADATA Data;
2104 int ret, err;
2105
2106 ret = WSAStartup(MAKEWORD(2,2), &Data);
2107 if (ret != 0) {
2108 err = WSAGetLastError();
2109 fprintf(stderr, "WSAStartup: %d\n", err);
2110 return -1;
2111 }
2112 atexit(socket_cleanup);
2113 return 0;
2114}
2115
2116static int send_all(int fd, const uint8_t *buf, int len1)
2117{
2118 int ret, len;
3b46e624 2119
fd1dff4b
FB		 2120 len = len1;
2121 while (len > 0) {
2122 ret = send(fd, buf, len, 0);
2123 if (ret < 0) {
2124 int errno;
2125 errno = WSAGetLastError();
2126 if (errno != WSAEWOULDBLOCK) {
2127 return -1;
2128 }
2129 } else if (ret == 0) {
2130 break;
2131 } else {
2132 buf += ret;
2133 len -= ret;
2134 }
2135 }
2136 return len1 - len;
2137}
2138
fd1dff4b
FB		 2139#else
2140
1d96905d
FB		 2141static int unix_write(int fd, const uint8_t *buf, int len1)
2142{
2143 int ret, len;
2144
2145 len = len1;
2146 while (len > 0) {
2147 ret = write(fd, buf, len);
2148 if (ret < 0) {
2149 if (errno != EINTR && errno != EAGAIN)
2150 return -1;
2151 } else if (ret == 0) {
2152 break;
2153 } else {
2154 buf += ret;
2155 len -= ret;
2156 }
2157 }
2158 return len1 - len;
2159}
2160
fd1dff4b
FB		 2161static inline int send_all(int fd, const uint8_t *buf, int len1)
2162{
2163 return unix_write(fd, buf, len1);
2164}
fd1dff4b
FB		 2165#endif /* !_WIN32 */
2166
2167#ifndef _WIN32
2168
2169typedef struct {
2170 int fd_in, fd_out;
fd1dff4b
FB		 2171 int max_size;
2172} FDCharDriver;
2173
20d8a3ed
TS		 2174#define STDIO_MAX_CLIENTS 1
2175static int stdio_nb_clients = 0;
fd1dff4b 2176
82c643ff
FB		 2177static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2178{
2179 FDCharDriver *s = chr->opaque;
1d96905d 2180 return unix_write(s->fd_out, buf, len);
82c643ff
FB		 2181}
2182
7c9d8e07
FB		 2183static int fd_chr_read_poll(void *opaque)
2184{
2185 CharDriverState *chr = opaque;
2186 FDCharDriver *s = chr->opaque;
2187
e5b0bc44 2188 s->max_size = qemu_chr_can_read(chr);
7c9d8e07
FB		 2189 return s->max_size;
2190}
2191
2192static void fd_chr_read(void *opaque)
2193{
2194 CharDriverState *chr = opaque;
2195 FDCharDriver *s = chr->opaque;
2196 int size, len;
2197 uint8_t buf[1024];
3b46e624 2198
7c9d8e07
FB		 2199 len = sizeof(buf);
2200 if (len > s->max_size)
2201 len = s->max_size;
2202 if (len == 0)
2203 return;
2204 size = read(s->fd_in, buf, len);
188157fe
PB		 2205 if (size == 0) {
2206 /* FD has been closed. Remove it from the active list. */
2207 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2208 return;
2209 }
7c9d8e07 2210 if (size > 0) {
e5b0bc44 2211 qemu_chr_read(chr, buf, size);
7c9d8e07
FB		 2212 }
2213}
2214
e5b0bc44 2215static void fd_chr_update_read_handler(CharDriverState *chr)
82c643ff
FB		 2216{
2217 FDCharDriver *s = chr->opaque;
2218
f8d179e3
FB		 2219 if (s->fd_in >= 0) {
2220 if (nographic && s->fd_in == 0) {
f8d179e3 2221 } else {
5fafdf24 2222 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
7c9d8e07 2223 fd_chr_read, NULL, chr);
f8d179e3 2224 }
82c643ff
FB		 2225 }
2226}
2227
a11d070e
AZ		 2228static void fd_chr_close(struct CharDriverState *chr)
2229{
2230 FDCharDriver *s = chr->opaque;
2231
2232 if (s->fd_in >= 0) {
2233 if (nographic && s->fd_in == 0) {
2234 } else {
2235 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2236 }
2237 }
2238
2239 qemu_free(s);
2240}
2241
82c643ff 2242/* open a character device to a unix fd */
52f61fde 2243static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
82c643ff
FB		 2244{
2245 CharDriverState *chr;
2246 FDCharDriver *s;
2247
2248 chr = qemu_mallocz(sizeof(CharDriverState));
2249 if (!chr)
2250 return NULL;
2251 s = qemu_mallocz(sizeof(FDCharDriver));
2252 if (!s) {
2253 free(chr);
2254 return NULL;
2255 }
2256 s->fd_in = fd_in;
2257 s->fd_out = fd_out;
2258 chr->opaque = s;
2259 chr->chr_write = fd_chr_write;
e5b0bc44 2260 chr->chr_update_read_handler = fd_chr_update_read_handler;
a11d070e 2261 chr->chr_close = fd_chr_close;
86e94dea
TS		 2262
2263 qemu_chr_reset(chr);
2264
82c643ff
FB		 2265 return chr;
2266}
2267
52f61fde 2268static CharDriverState *qemu_chr_open_file_out(const char *file_out)
f8d179e3
FB		 2269{
2270 int fd_out;
2271
aeb30be6 2272 TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
f8d179e3
FB		 2273 if (fd_out < 0)
2274 return NULL;
2275 return qemu_chr_open_fd(-1, fd_out);
2276}
2277
52f61fde 2278static CharDriverState *qemu_chr_open_pipe(const char *filename)
f8d179e3 2279{
c26c1c4b
TS		 2280 int fd_in, fd_out;
2281 char filename_in[256], filename_out[256];
2282
2283 snprintf(filename_in, 256, "%s.in", filename);
2284 snprintf(filename_out, 256, "%s.out", filename);
aeb30be6
AZ		 2285 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2286 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
c26c1c4b
TS		 2287 if (fd_in < 0 || fd_out < 0) {
2288 if (fd_in >= 0)
2289 close(fd_in);
2290 if (fd_out >= 0)
2291 close(fd_out);
aeb30be6 2292 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
c26c1c4b
TS		 2293 if (fd_in < 0)
2294 return NULL;
2295 }
2296 return qemu_chr_open_fd(fd_in, fd_out);
f8d179e3
FB		 2297}
2298
2299
82c643ff
FB		 2300/* for STDIO, we handle the case where several clients use it
2301 (nographic mode) */
2302
aa0bc6b6
FB		 2303#define TERM_FIFO_MAX_SIZE 1
2304
aa0bc6b6 2305static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1dce7c3c 2306static int term_fifo_size;
330d0414 2307
7c9d8e07 2308static int stdio_read_poll(void *opaque)
82c643ff 2309{
20d8a3ed 2310 CharDriverState *chr = opaque;
aa0bc6b6 2311
20d8a3ed
TS		 2312 /* try to flush the queue if needed */
2313 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2314 qemu_chr_read(chr, term_fifo, 1);
2315 term_fifo_size = 0;
aa0bc6b6 2316 }
20d8a3ed
TS		 2317 /* see if we can absorb more chars */
2318 if (term_fifo_size == 0)
2319 return 1;
2320 else
2321 return 0;
82c643ff
FB		 2322}
2323
7c9d8e07 2324static void stdio_read(void *opaque)
82c643ff 2325{
7c9d8e07
FB		 2326 int size;
2327 uint8_t buf[1];
20d8a3ed
TS		 2328 CharDriverState *chr = opaque;
2329
7c9d8e07 2330 size = read(0, buf, 1);
519945df
PB		 2331 if (size == 0) {
2332 /* stdin has been closed. Remove it from the active list. */
2333 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2334 return;
2335 }
20d8a3ed
TS		 2336 if (size > 0) {
2337 if (qemu_chr_can_read(chr) > 0) {
2338 qemu_chr_read(chr, buf, 1);
2339 } else if (term_fifo_size == 0) {
2340 term_fifo[term_fifo_size++] = buf[0];
1dce7c3c 2341 }
1dce7c3c
FB		 2342 }
2343}
2344
8d11df9e
FB		 2345/* init terminal so that we can grab keys */
2346static struct termios oldtty;
2347static int old_fd0_flags;
a11d070e 2348static int term_atexit_done;
8d11df9e
FB		 2349
2350static void term_exit(void)
2351{
2352 tcsetattr (0, TCSANOW, &oldtty);
2353 fcntl(0, F_SETFL, old_fd0_flags);
2354}
2355
2356static void term_init(void)
2357{
2358 struct termios tty;
2359
2360 tcgetattr (0, &tty);
2361 oldtty = tty;
2362 old_fd0_flags = fcntl(0, F_GETFL);
2363
2364 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2365 |INLCR|IGNCR|ICRNL|IXON);
2366 tty.c_oflag |= OPOST;
2367 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2368 /* if graphical mode, we allow Ctrl-C handling */
2369 if (nographic)
2370 tty.c_lflag &= ~ISIG;
2371 tty.c_cflag &= ~(CSIZE|PARENB);
2372 tty.c_cflag |= CS8;
2373 tty.c_cc[VMIN] = 1;
2374 tty.c_cc[VTIME] = 0;
3b46e624 2375
8d11df9e
FB		 2376 tcsetattr (0, TCSANOW, &tty);
2377
a11d070e
AZ		 2378 if (!term_atexit_done++)
2379 atexit(term_exit);
8d11df9e
FB		 2380
2381 fcntl(0, F_SETFL, O_NONBLOCK);
2382}
2383
a11d070e
AZ		 2384static void qemu_chr_close_stdio(struct CharDriverState *chr)
2385{
2386 term_exit();
2387 stdio_nb_clients--;
2388 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2389 fd_chr_close(chr);
2390}
2391
52f61fde 2392static CharDriverState *qemu_chr_open_stdio(void)
82c643ff
FB		 2393{
2394 CharDriverState *chr;
2395
20d8a3ed
TS		 2396 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2397 return NULL;
2398 chr = qemu_chr_open_fd(0, 1);
a11d070e 2399 chr->chr_close = qemu_chr_close_stdio;
20d8a3ed
TS		 2400 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2401 stdio_nb_clients++;
2402 term_init();
2403
82c643ff
FB		 2404 return chr;
2405}
2406
64b7b733
AJ		 2407#ifdef __sun__
2408/* Once Solaris has openpty(), this is going to be removed. */
2409int openpty(int *amaster, int *aslave, char *name,
2410 struct termios *termp, struct winsize *winp)
2411{
2412 const char *slave;
2413 int mfd = -1, sfd = -1;
2414
2415 *amaster = *aslave = -1;
2416
2417 mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
2418 if (mfd < 0)
2419 goto err;
2420
2421 if (grantpt(mfd) == -1 || unlockpt(mfd) == -1)
2422 goto err;
2423
2424 if ((slave = ptsname(mfd)) == NULL)
2425 goto err;
2426
2427 if ((sfd = open(slave, O_RDONLY | O_NOCTTY)) == -1)
2428 goto err;
2429
2430 if (ioctl(sfd, I_PUSH, "ptem") == -1 ||
2431 (termp != NULL && tcgetattr(sfd, termp) < 0))
2432 goto err;
2433
2434 if (amaster)
2435 *amaster = mfd;
2436 if (aslave)
2437 *aslave = sfd;
2438 if (winp)
2439 ioctl(sfd, TIOCSWINSZ, winp);
2440
2441 return 0;
2442
2443err:
2444 if (sfd != -1)
2445 close(sfd);
2446 close(mfd);
2447 return -1;
2448}
2449
2450void cfmakeraw (struct termios *termios_p)
2451{
2452 termios_p->c_iflag &=
2453 ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2454 termios_p->c_oflag &= ~OPOST;
2455 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2456 termios_p->c_cflag &= ~(CSIZE|PARENB);
2457 termios_p->c_cflag |= CS8;
2458
2459 termios_p->c_cc[VMIN] = 0;
2460 termios_p->c_cc[VTIME] = 0;
2461}
2462#endif
2463
9892fbfb
BS		 2464#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2465 || defined(__NetBSD__) || defined(__OpenBSD__)
279e694b
AL		 2466
2467typedef struct {
2468 int fd;
2469 int connected;
2470 int polling;
2471 int read_bytes;
2472 QEMUTimer *timer;
2473} PtyCharDriver;
2474
2475static void pty_chr_update_read_handler(CharDriverState *chr);
2476static void pty_chr_state(CharDriverState *chr, int connected);
2477
2478static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2479{
2480 PtyCharDriver *s = chr->opaque;
2481
2482 if (!s->connected) {
2483 /* guest sends data, check for (re-)connect */
2484 pty_chr_update_read_handler(chr);
2485 return 0;
2486 }
2487 return unix_write(s->fd, buf, len);
2488}
2489
2490static int pty_chr_read_poll(void *opaque)
2491{
2492 CharDriverState *chr = opaque;
2493 PtyCharDriver *s = chr->opaque;
2494
2495 s->read_bytes = qemu_chr_can_read(chr);
2496 return s->read_bytes;
2497}
2498
2499static void pty_chr_read(void *opaque)
2500{
2501 CharDriverState *chr = opaque;
2502 PtyCharDriver *s = chr->opaque;
2503 int size, len;
2504 uint8_t buf[1024];
2505
2506 len = sizeof(buf);
2507 if (len > s->read_bytes)
2508 len = s->read_bytes;
2509 if (len == 0)
2510 return;
2511 size = read(s->fd, buf, len);
2512 if ((size == -1 && errno == EIO) ||
2513 (size == 0)) {
2514 pty_chr_state(chr, 0);
2515 return;
2516 }
2517 if (size > 0) {
2518 pty_chr_state(chr, 1);
2519 qemu_chr_read(chr, buf, size);
2520 }
2521}
2522
2523static void pty_chr_update_read_handler(CharDriverState *chr)
2524{
2525 PtyCharDriver *s = chr->opaque;
2526
2527 qemu_set_fd_handler2(s->fd, pty_chr_read_poll,
2528 pty_chr_read, NULL, chr);
2529 s->polling = 1;
2530 /*
2531 * Short timeout here: just need wait long enougth that qemu makes
2532 * it through the poll loop once. When reconnected we want a
2533 * short timeout so we notice it almost instantly. Otherwise
2534 * read() gives us -EIO instantly, making pty_chr_state() reset the
2535 * timeout to the normal (much longer) poll interval before the
2536 * timer triggers.
2537 */
2538 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10);
2539}
2540
2541static void pty_chr_state(CharDriverState *chr, int connected)
2542{
2543 PtyCharDriver *s = chr->opaque;
2544
2545 if (!connected) {
2546 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2547 s->connected = 0;
2548 s->polling = 0;
2549 /* (re-)connect poll interval for idle guests: once per second.
2550 * We check more frequently in case the guests sends data to
2551 * the virtual device linked to our pty. */
2552 qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000);
2553 } else {
2554 if (!s->connected)
2555 qemu_chr_reset(chr);
2556 s->connected = 1;
2557 }
2558}
2559
8fcd3692 2560static void pty_chr_timer(void *opaque)
279e694b
AL		 2561{
2562 struct CharDriverState *chr = opaque;
2563 PtyCharDriver *s = chr->opaque;
2564
2565 if (s->connected)
2566 return;
2567 if (s->polling) {
2568 /* If we arrive here without polling being cleared due
2569 * read returning -EIO, then we are (re-)connected */
2570 pty_chr_state(chr, 1);
2571 return;
2572 }
2573
2574 /* Next poll ... */
2575 pty_chr_update_read_handler(chr);
2576}
2577
2578static void pty_chr_close(struct CharDriverState *chr)
2579{
2580 PtyCharDriver *s = chr->opaque;
2581
2582 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
2583 close(s->fd);
2584 qemu_free(s);
2585}
2586
52f61fde 2587static CharDriverState *qemu_chr_open_pty(void)
82c643ff 2588{
279e694b
AL		 2589 CharDriverState *chr;
2590 PtyCharDriver *s;
91fc2119 2591 struct termios tty;
279e694b 2592 int slave_fd;
9892fbfb
BS		 2593#if defined(__OpenBSD__)
2594 char pty_name[PATH_MAX];
2595#define q_ptsname(x) pty_name
2596#else
2597 char *pty_name = NULL;
2598#define q_ptsname(x) ptsname(x)
2599#endif
279e694b
AL		 2600
2601 chr = qemu_mallocz(sizeof(CharDriverState));
2602 if (!chr)
2603 return NULL;
2604 s = qemu_mallocz(sizeof(PtyCharDriver));
2605 if (!s) {
2606 qemu_free(chr);
2607 return NULL;
2608 }
3b46e624 2609
9892fbfb 2610 if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
82c643ff
FB		 2611 return NULL;
2612 }
3b46e624 2613
64b7b733
AJ		 2614 /* Set raw attributes on the pty. */
2615 cfmakeraw(&tty);
2616 tcsetattr(slave_fd, TCSAFLUSH, &tty);
279e694b
AL		 2617 close(slave_fd);
2618
9892fbfb 2619 fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
91fc2119 2620
279e694b
AL		 2621 chr->opaque = s;
2622 chr->chr_write = pty_chr_write;
2623 chr->chr_update_read_handler = pty_chr_update_read_handler;
2624 chr->chr_close = pty_chr_close;
2625
2626 s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr);
2627
2628 return chr;
82c643ff 2629}
f8d179e3 2630
5fafdf24 2631static void tty_serial_init(int fd, int speed,
f8d179e3
FB		 2632 int parity, int data_bits, int stop_bits)
2633{
2634 struct termios tty;
2635 speed_t spd;
2636
e57a8c0e 2637#if 0
5fafdf24 2638 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
e57a8c0e
FB		 2639 speed, parity, data_bits, stop_bits);
2640#endif
2641 tcgetattr (fd, &tty);
f8d179e3 2642
a7954218
AZ		 2643#define MARGIN 1.1
2644 if (speed <= 50 * MARGIN)
f8d179e3 2645 spd = B50;
a7954218 2646 else if (speed <= 75 * MARGIN)
f8d179e3 2647 spd = B75;
a7954218 2648 else if (speed <= 300 * MARGIN)
f8d179e3 2649 spd = B300;
a7954218 2650 else if (speed <= 600 * MARGIN)
f8d179e3 2651 spd = B600;
a7954218 2652 else if (speed <= 1200 * MARGIN)
f8d179e3 2653 spd = B1200;
a7954218 2654 else if (speed <= 2400 * MARGIN)
f8d179e3 2655 spd = B2400;
a7954218 2656 else if (speed <= 4800 * MARGIN)
f8d179e3 2657 spd = B4800;
a7954218 2658 else if (speed <= 9600 * MARGIN)
f8d179e3 2659 spd = B9600;
a7954218 2660 else if (speed <= 19200 * MARGIN)
f8d179e3 2661 spd = B19200;
a7954218 2662 else if (speed <= 38400 * MARGIN)
f8d179e3 2663 spd = B38400;
a7954218 2664 else if (speed <= 57600 * MARGIN)
f8d179e3 2665 spd = B57600;
a7954218
AZ		 2666 else if (speed <= 115200 * MARGIN)
2667 spd = B115200;
2668 else
f8d179e3 2669 spd = B115200;
f8d179e3
FB		 2670
2671 cfsetispeed(&tty, spd);
2672 cfsetospeed(&tty, spd);
2673
2674 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2675 |INLCR|IGNCR|ICRNL|IXON);
2676 tty.c_oflag |= OPOST;
2677 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
094eed6c 2678 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
f8d179e3
FB		 2679 switch(data_bits) {
2680 default:
2681 case 8:
2682 tty.c_cflag |= CS8;
2683 break;
2684 case 7:
2685 tty.c_cflag |= CS7;
2686 break;
2687 case 6:
2688 tty.c_cflag |= CS6;
2689 break;
2690 case 5:
2691 tty.c_cflag |= CS5;
2692 break;
2693 }
2694 switch(parity) {
2695 default:
2696 case 'N':
2697 break;
2698 case 'E':
2699 tty.c_cflag |= PARENB;
2700 break;
2701 case 'O':
2702 tty.c_cflag |= PARENB | PARODD;
2703 break;
2704 }
094eed6c
FB		 2705 if (stop_bits == 2)
2706 tty.c_cflag |= CSTOPB;
3b46e624 2707
f8d179e3
FB		 2708 tcsetattr (fd, TCSANOW, &tty);
2709}
2710
e57a8c0e 2711static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
f8d179e3
FB		 2712{
2713 FDCharDriver *s = chr->opaque;
3b46e624 2714
e57a8c0e
FB		 2715 switch(cmd) {
2716 case CHR_IOCTL_SERIAL_SET_PARAMS:
2717 {
2718 QEMUSerialSetParams *ssp = arg;
5fafdf24 2719 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
e57a8c0e
FB		 2720 ssp->data_bits, ssp->stop_bits);
2721 }
2722 break;
2723 case CHR_IOCTL_SERIAL_SET_BREAK:
2724 {
2725 int enable = *(int *)arg;
2726 if (enable)
2727 tcsendbreak(s->fd_in, 1);
2728 }
2729 break;
81174dae
AL		 2730 case CHR_IOCTL_SERIAL_GET_TIOCM:
2731 {
2732 int sarg = 0;
2733 int *targ = (int *)arg;
2734 ioctl(s->fd_in, TIOCMGET, &sarg);
2735 *targ = 0;
2736 if (sarg | TIOCM_CTS)
2737 *targ |= CHR_TIOCM_CTS;
2738 if (sarg | TIOCM_CAR)
2739 *targ |= CHR_TIOCM_CAR;
2740 if (sarg | TIOCM_DSR)
2741 *targ |= CHR_TIOCM_DSR;
2742 if (sarg | TIOCM_RI)
2743 *targ |= CHR_TIOCM_RI;
2744 if (sarg | TIOCM_DTR)
2745 *targ |= CHR_TIOCM_DTR;
2746 if (sarg | TIOCM_RTS)
2747 *targ |= CHR_TIOCM_RTS;
2748 }
2749 break;
2750 case CHR_IOCTL_SERIAL_SET_TIOCM:
2751 {
2752 int sarg = *(int *)arg;
2753 int targ = 0;
2754 if (sarg | CHR_TIOCM_DTR)
2755 targ |= TIOCM_DTR;
2756 if (sarg | CHR_TIOCM_RTS)
2757 targ |= TIOCM_RTS;
2758 ioctl(s->fd_in, TIOCMSET, &targ);
2759 }
2760 break;
e57a8c0e
FB		 2761 default:
2762 return -ENOTSUP;
2763 }
2764 return 0;
f8d179e3
FB		 2765}
2766
52f61fde 2767static CharDriverState *qemu_chr_open_tty(const char *filename)
f8d179e3
FB		 2768{
2769 CharDriverState *chr;
2770 int fd;
2771
aeb30be6 2772 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
f8d179e3
FB		 2773 tty_serial_init(fd, 115200, 'N', 8, 1);
2774 chr = qemu_chr_open_fd(fd, fd);
aeb30be6
AZ		 2775 if (!chr) {
2776 close(fd);
f8d179e3 2777 return NULL;
aeb30be6 2778 }
e57a8c0e 2779 chr->chr_ioctl = tty_serial_ioctl;
86e94dea 2780 qemu_chr_reset(chr);
e57a8c0e
FB		 2781 return chr;
2782}
aec62507
TS		 2783#else /* ! __linux__ && ! __sun__ */
2784static CharDriverState *qemu_chr_open_pty(void)
2785{
2786 return NULL;
2787}
2788#endif /* __linux__ || __sun__ */
e57a8c0e 2789
aec62507 2790#if defined(__linux__)
5867c88a
TS		 2791typedef struct {
2792 int fd;
2793 int mode;
2794} ParallelCharDriver;
2795
2796static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2797{
2798 if (s->mode != mode) {
2799 int m = mode;
2800 if (ioctl(s->fd, PPSETMODE, &m) < 0)
2801 return 0;
2802 s->mode = mode;
2803 }
2804 return 1;
2805}
2806
e57a8c0e
FB		 2807static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2808{
5867c88a
TS		 2809 ParallelCharDriver *drv = chr->opaque;
2810 int fd = drv->fd;
e57a8c0e
FB		 2811 uint8_t b;
2812
2813 switch(cmd) {
2814 case CHR_IOCTL_PP_READ_DATA:
2815 if (ioctl(fd, PPRDATA, &b) < 0)
2816 return -ENOTSUP;
2817 *(uint8_t *)arg = b;
2818 break;
2819 case CHR_IOCTL_PP_WRITE_DATA:
2820 b = *(uint8_t *)arg;
2821 if (ioctl(fd, PPWDATA, &b) < 0)
2822 return -ENOTSUP;
2823 break;
2824 case CHR_IOCTL_PP_READ_CONTROL:
2825 if (ioctl(fd, PPRCONTROL, &b) < 0)
2826 return -ENOTSUP;
5867c88a
TS		 2827 /* Linux gives only the lowest bits, and no way to know data
2828 direction! For better compatibility set the fixed upper
2829 bits. */
2830 *(uint8_t *)arg = b | 0xc0;
e57a8c0e
FB		 2831 break;
2832 case CHR_IOCTL_PP_WRITE_CONTROL:
2833 b = *(uint8_t *)arg;
2834 if (ioctl(fd, PPWCONTROL, &b) < 0)
2835 return -ENOTSUP;
2836 break;
2837 case CHR_IOCTL_PP_READ_STATUS:
2838 if (ioctl(fd, PPRSTATUS, &b) < 0)
2839 return -ENOTSUP;
2840 *(uint8_t *)arg = b;
2841 break;
563e3c6e
AJ		 2842 case CHR_IOCTL_PP_DATA_DIR:
2843 if (ioctl(fd, PPDATADIR, (int *)arg) < 0)
2844 return -ENOTSUP;
2845 break;
5867c88a
TS		 2846 case CHR_IOCTL_PP_EPP_READ_ADDR:
2847 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2848 struct ParallelIOArg *parg = arg;
2849 int n = read(fd, parg->buffer, parg->count);
2850 if (n != parg->count) {
2851 return -EIO;
2852 }
2853 }
2854 break;
2855 case CHR_IOCTL_PP_EPP_READ:
2856 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2857 struct ParallelIOArg *parg = arg;
2858 int n = read(fd, parg->buffer, parg->count);
2859 if (n != parg->count) {
2860 return -EIO;
2861 }
2862 }
2863 break;
2864 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2865 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2866 struct ParallelIOArg *parg = arg;
2867 int n = write(fd, parg->buffer, parg->count);
2868 if (n != parg->count) {
2869 return -EIO;
2870 }
2871 }
2872 break;
2873 case CHR_IOCTL_PP_EPP_WRITE:
2874 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2875 struct ParallelIOArg *parg = arg;
2876 int n = write(fd, parg->buffer, parg->count);
2877 if (n != parg->count) {
2878 return -EIO;
2879 }
2880 }
2881 break;
e57a8c0e
FB		 2882 default:
2883 return -ENOTSUP;
2884 }
2885 return 0;
2886}
2887
5867c88a
TS		 2888static void pp_close(CharDriverState *chr)
2889{
2890 ParallelCharDriver *drv = chr->opaque;
2891 int fd = drv->fd;
2892
2893 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2894 ioctl(fd, PPRELEASE);
2895 close(fd);
2896 qemu_free(drv);
2897}
2898
52f61fde 2899static CharDriverState *qemu_chr_open_pp(const char *filename)
e57a8c0e
FB		 2900{
2901 CharDriverState *chr;
5867c88a 2902 ParallelCharDriver *drv;
e57a8c0e
FB		 2903 int fd;
2904
aeb30be6 2905 TFR(fd = open(filename, O_RDWR));
e57a8c0e
FB		 2906 if (fd < 0)
2907 return NULL;
2908
2909 if (ioctl(fd, PPCLAIM) < 0) {
2910 close(fd);
2911 return NULL;
2912 }
2913
5867c88a
TS		 2914 drv = qemu_mallocz(sizeof(ParallelCharDriver));
2915 if (!drv) {
2916 close(fd);
2917 return NULL;
2918 }
2919 drv->fd = fd;
2920 drv->mode = IEEE1284_MODE_COMPAT;
2921
e57a8c0e
FB		 2922 chr = qemu_mallocz(sizeof(CharDriverState));
2923 if (!chr) {
5867c88a 2924 qemu_free(drv);
e57a8c0e
FB		 2925 close(fd);
2926 return NULL;
2927 }
e57a8c0e 2928 chr->chr_write = null_chr_write;
e57a8c0e 2929 chr->chr_ioctl = pp_ioctl;
5867c88a
TS		 2930 chr->chr_close = pp_close;
2931 chr->opaque = drv;
86e94dea
TS		 2932
2933 qemu_chr_reset(chr);
2934
f8d179e3
FB		 2935 return chr;
2936}
aec62507 2937#endif /* __linux__ */
f8d179e3 2938
aec62507 2939#else /* _WIN32 */
82c643ff 2940
f331110f 2941typedef struct {
f331110f
FB		 2942 int max_size;
2943 HANDLE hcom, hrecv, hsend;
2944 OVERLAPPED orecv, osend;
2945 BOOL fpipe;
2946 DWORD len;
2947} WinCharState;
2948
2949#define NSENDBUF 2048
2950#define NRECVBUF 2048
2951#define MAXCONNECT 1
2952#define NTIMEOUT 5000
2953
2954static int win_chr_poll(void *opaque);
2955static int win_chr_pipe_poll(void *opaque);
2956
087f4ae0 2957static void win_chr_close(CharDriverState *chr)
f331110f 2958{
087f4ae0
TS		 2959 WinCharState *s = chr->opaque;
2960
f331110f
FB		 2961 if (s->hsend) {
2962 CloseHandle(s->hsend);
2963 s->hsend = NULL;
2964 }
2965 if (s->hrecv) {
2966 CloseHandle(s->hrecv);
2967 s->hrecv = NULL;
2968 }
2969 if (s->hcom) {
2970 CloseHandle(s->hcom);
2971 s->hcom = NULL;
2972 }
2973 if (s->fpipe)
087f4ae0 2974 qemu_del_polling_cb(win_chr_pipe_poll, chr);
f331110f 2975 else
087f4ae0 2976 qemu_del_polling_cb(win_chr_poll, chr);
f331110f
FB		 2977}
2978
087f4ae0 2979static int win_chr_init(CharDriverState *chr, const char *filename)
f331110f
FB		 2980{
2981 WinCharState *s = chr->opaque;
f331110f
FB		 2982 COMMCONFIG comcfg;
2983 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2984 COMSTAT comstat;
2985 DWORD size;
2986 DWORD err;
3b46e624 2987
f331110f
FB		 2988 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2989 if (!s->hsend) {
2990 fprintf(stderr, "Failed CreateEvent\n");
2991 goto fail;
2992 }
2993 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2994 if (!s->hrecv) {
2995 fprintf(stderr, "Failed CreateEvent\n");
2996 goto fail;
2997 }
2998
2999 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
3000 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
3001 if (s->hcom == INVALID_HANDLE_VALUE) {
3002 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
3003 s->hcom = NULL;
3004 goto fail;
3005 }
3b46e624 3006
f331110f
FB		 3007 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
3008 fprintf(stderr, "Failed SetupComm\n");
3009 goto fail;
3010 }
3b46e624 3011
f331110f
FB		 3012 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
3013 size = sizeof(COMMCONFIG);
3014 GetDefaultCommConfig(filename, &comcfg, &size);
3015 comcfg.dcb.DCBlength = sizeof(DCB);
3016 CommConfigDialog(filename, NULL, &comcfg);
3017
3018 if (!SetCommState(s->hcom, &comcfg.dcb)) {
3019 fprintf(stderr, "Failed SetCommState\n");
3020 goto fail;
3021 }
3022
3023 if (!SetCommMask(s->hcom, EV_ERR)) {
3024 fprintf(stderr, "Failed SetCommMask\n");
3025 goto fail;
3026 }
3027
3028 cto.ReadIntervalTimeout = MAXDWORD;
3029 if (!SetCommTimeouts(s->hcom, &cto)) {
3030 fprintf(stderr, "Failed SetCommTimeouts\n");
3031 goto fail;
3032 }
3b46e624 3033
f331110f
FB		 3034 if (!ClearCommError(s->hcom, &err, &comstat)) {
3035 fprintf(stderr, "Failed ClearCommError\n");
3036 goto fail;
3037 }
087f4ae0 3038 qemu_add_polling_cb(win_chr_poll, chr);
f331110f
FB		 3039 return 0;
3040
3041 fail:
087f4ae0 3042 win_chr_close(chr);
f331110f
FB		 3043 return -1;
3044}
3045
3046static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
3047{
3048 WinCharState *s = chr->opaque;
3049 DWORD len, ret, size, err;
3050
3051 len = len1;
3052 ZeroMemory(&s->osend, sizeof(s->osend));
3053 s->osend.hEvent = s->hsend;
3054 while (len > 0) {
3055 if (s->hsend)
3056 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
3057 else
3058 ret = WriteFile(s->hcom, buf, len, &size, NULL);
3059 if (!ret) {
3060 err = GetLastError();
3061 if (err == ERROR_IO_PENDING) {
3062 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
3063 if (ret) {
3064 buf += size;
3065 len -= size;
3066 } else {
3067 break;
3068 }
3069 } else {
3070 break;
3071 }
3072 } else {
3073 buf += size;
3074 len -= size;
3075 }
3076 }
3077 return len1 - len;
3078}
3079
087f4ae0 3080static int win_chr_read_poll(CharDriverState *chr)
f331110f 3081{
087f4ae0
TS		 3082 WinCharState *s = chr->opaque;
3083
3084 s->max_size = qemu_chr_can_read(chr);
f331110f
FB		 3085 return s->max_size;
3086}
e5b0bc44 3087
087f4ae0 3088static void win_chr_readfile(CharDriverState *chr)
f331110f 3089{
087f4ae0 3090 WinCharState *s = chr->opaque;
f331110f
FB		 3091 int ret, err;
3092 uint8_t buf[1024];
3093 DWORD size;
3b46e624 3094
f331110f
FB		 3095 ZeroMemory(&s->orecv, sizeof(s->orecv));
3096 s->orecv.hEvent = s->hrecv;
3097 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
3098 if (!ret) {
3099 err = GetLastError();
3100 if (err == ERROR_IO_PENDING) {
3101 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
3102 }
3103 }
3104
3105 if (size > 0) {
087f4ae0 3106 qemu_chr_read(chr, buf, size);
f331110f
FB		 3107 }
3108}
3109
087f4ae0 3110static void win_chr_read(CharDriverState *chr)
f331110f 3111{
087f4ae0
TS		 3112 WinCharState *s = chr->opaque;
3113
f331110f
FB		 3114 if (s->len > s->max_size)
3115 s->len = s->max_size;
3116 if (s->len == 0)
3117 return;
3b46e624 3118
087f4ae0 3119 win_chr_readfile(chr);
f331110f
FB		 3120}
3121
3122static int win_chr_poll(void *opaque)
3123{
087f4ae0
TS		 3124 CharDriverState *chr = opaque;
3125 WinCharState *s = chr->opaque;
f331110f
FB		 3126 COMSTAT status;
3127 DWORD comerr;
3b46e624 3128
f331110f
FB		 3129 ClearCommError(s->hcom, &comerr, &status);
3130 if (status.cbInQue > 0) {
3131 s->len = status.cbInQue;
087f4ae0
TS		 3132 win_chr_read_poll(chr);
3133 win_chr_read(chr);
f331110f
FB		 3134 return 1;
3135 }
3136 return 0;
3137}
3138
52f61fde 3139static CharDriverState *qemu_chr_open_win(const char *filename)
f331110f
FB		 3140{
3141 CharDriverState *chr;
3142 WinCharState *s;
3b46e624 3143
f331110f
FB		 3144 chr = qemu_mallocz(sizeof(CharDriverState));
3145 if (!chr)
3146 return NULL;
3147 s = qemu_mallocz(sizeof(WinCharState));
3148 if (!s) {
3149 free(chr);
3150 return NULL;
3151 }
3152 chr->opaque = s;
3153 chr->chr_write = win_chr_write;
f331110f
FB		 3154 chr->chr_close = win_chr_close;
3155
087f4ae0 3156 if (win_chr_init(chr, filename) < 0) {
f331110f
FB		 3157 free(s);
3158 free(chr);
3159 return NULL;
3160 }
86e94dea 3161 qemu_chr_reset(chr);
f331110f
FB		 3162 return chr;
3163}
3164
3165static int win_chr_pipe_poll(void *opaque)
3166{
087f4ae0
TS		 3167 CharDriverState *chr = opaque;
3168 WinCharState *s = chr->opaque;
f331110f
FB		 3169 DWORD size;
3170
3171 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
3172 if (size > 0) {
3173 s->len = size;
087f4ae0
TS		 3174 win_chr_read_poll(chr);
3175 win_chr_read(chr);
f331110f
FB		 3176 return 1;
3177 }
3178 return 0;
3179}
3180
087f4ae0 3181static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
f331110f 3182{
087f4ae0 3183 WinCharState *s = chr->opaque;
f331110f
FB		 3184 OVERLAPPED ov;
3185 int ret;
3186 DWORD size;
3187 char openname[256];
3b46e624 3188
f331110f
FB		 3189 s->fpipe = TRUE;
3190
3191 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
3192 if (!s->hsend) {
3193 fprintf(stderr, "Failed CreateEvent\n");
3194 goto fail;
3195 }
3196 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
3197 if (!s->hrecv) {
3198 fprintf(stderr, "Failed CreateEvent\n");
3199 goto fail;
3200 }
3b46e624 3201
f331110f
FB		 3202 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
3203 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
3204 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
3205 PIPE_WAIT,
3206 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
3207 if (s->hcom == INVALID_HANDLE_VALUE) {
3208 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3209 s->hcom = NULL;
3210 goto fail;
3211 }
3212
3213 ZeroMemory(&ov, sizeof(ov));
3214 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
3215 ret = ConnectNamedPipe(s->hcom, &ov);
3216 if (ret) {
3217 fprintf(stderr, "Failed ConnectNamedPipe\n");
3218 goto fail;
3219 }
3220
3221 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
3222 if (!ret) {
3223 fprintf(stderr, "Failed GetOverlappedResult\n");
3224 if (ov.hEvent) {
3225 CloseHandle(ov.hEvent);
3226 ov.hEvent = NULL;
3227 }
3228 goto fail;
3229 }
3230
3231 if (ov.hEvent) {
3232 CloseHandle(ov.hEvent);
3233 ov.hEvent = NULL;
3234 }
087f4ae0 3235 qemu_add_polling_cb(win_chr_pipe_poll, chr);
f331110f
FB		 3236 return 0;
3237
3238 fail:
087f4ae0 3239 win_chr_close(chr);
f331110f
FB		 3240 return -1;
3241}
3242
3243
52f61fde 3244static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
f331110f
FB		 3245{
3246 CharDriverState *chr;
3247 WinCharState *s;
3248
3249 chr = qemu_mallocz(sizeof(CharDriverState));
3250 if (!chr)
3251 return NULL;
3252 s = qemu_mallocz(sizeof(WinCharState));
3253 if (!s) {
3254 free(chr);
3255 return NULL;
3256 }
3257 chr->opaque = s;
3258 chr->chr_write = win_chr_write;
f331110f 3259 chr->chr_close = win_chr_close;
3b46e624 3260
087f4ae0 3261 if (win_chr_pipe_init(chr, filename) < 0) {
f331110f
FB		 3262 free(s);
3263 free(chr);
3264 return NULL;
3265 }
86e94dea 3266 qemu_chr_reset(chr);
f331110f
FB		 3267 return chr;
3268}
3269
52f61fde 3270static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
f331110f
FB		 3271{
3272 CharDriverState *chr;
3273 WinCharState *s;
3274
3275 chr = qemu_mallocz(sizeof(CharDriverState));
3276 if (!chr)
3277 return NULL;
3278 s = qemu_mallocz(sizeof(WinCharState));
3279 if (!s) {
3280 free(chr);
3281 return NULL;
3282 }
3283 s->hcom = fd_out;
3284 chr->opaque = s;
3285 chr->chr_write = win_chr_write;
86e94dea 3286 qemu_chr_reset(chr);
f331110f
FB		 3287 return chr;
3288}
72d46479
TS		 3289
3290static CharDriverState *qemu_chr_open_win_con(const char *filename)
3291{
3292 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
3293}
3294
52f61fde 3295static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
f331110f
FB		 3296{
3297 HANDLE fd_out;
3b46e624 3298
f331110f
FB		 3299 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
3300 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
3301 if (fd_out == INVALID_HANDLE_VALUE)
3302 return NULL;
3303
3304 return qemu_chr_open_win_file(fd_out);
3305}
aec62507 3306#endif /* !_WIN32 */
f331110f 3307
0bab00f3
FB		 3308/***********************************************************/
3309/* UDP Net console */
3310
3311typedef struct {
0bab00f3
FB		 3312 int fd;
3313 struct sockaddr_in daddr;
60fe76f3 3314 uint8_t buf[1024];
0bab00f3
FB		 3315 int bufcnt;
3316 int bufptr;
3317 int max_size;
3318} NetCharDriver;
3319
3320static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3321{
3322 NetCharDriver *s = chr->opaque;
3323
3324 return sendto(s->fd, buf, len, 0,
3325 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
3326}
3327
3328static int udp_chr_read_poll(void *opaque)
3329{
3330 CharDriverState *chr = opaque;
3331 NetCharDriver *s = chr->opaque;
3332
e5b0bc44 3333 s->max_size = qemu_chr_can_read(chr);
0bab00f3
FB		 3334
3335 /* If there were any stray characters in the queue process them
3336 * first
3337 */
3338 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
e5b0bc44 3339 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
0bab00f3 3340 s->bufptr++;
e5b0bc44 3341 s->max_size = qemu_chr_can_read(chr);
0bab00f3
FB		 3342 }
3343 return s->max_size;
3344}
3345
3346static void udp_chr_read(void *opaque)
3347{
3348 CharDriverState *chr = opaque;
3349 NetCharDriver *s = chr->opaque;
3350
3351 if (s->max_size == 0)
3352 return;
3353 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
3354 s->bufptr = s->bufcnt;
3355 if (s->bufcnt <= 0)
3356 return;
3357
3358 s->bufptr = 0;
3359 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
e5b0bc44 3360 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
0bab00f3 3361 s->bufptr++;
e5b0bc44 3362 s->max_size = qemu_chr_can_read(chr);
0bab00f3
FB		 3363 }
3364}
3365
e5b0bc44 3366static void udp_chr_update_read_handler(CharDriverState *chr)
0bab00f3
FB		 3367{
3368 NetCharDriver *s = chr->opaque;
3369
3370 if (s->fd >= 0) {
0bab00f3
FB		 3371 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3372 udp_chr_read, NULL, chr);
3373 }
3374}
3375
3376int parse_host_port(struct sockaddr_in *saddr, const char *str);
52f61fde
TS		 3377#ifndef _WIN32
3378static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3379#endif
951f1351
FB		 3380int parse_host_src_port(struct sockaddr_in *haddr,
3381 struct sockaddr_in *saddr,
3382 const char *str);
0bab00f3 3383
52f61fde 3384static CharDriverState *qemu_chr_open_udp(const char *def)
0bab00f3
FB		 3385{
3386 CharDriverState *chr = NULL;
3387 NetCharDriver *s = NULL;
3388 int fd = -1;
951f1351 3389 struct sockaddr_in saddr;
0bab00f3
FB		 3390
3391 chr = qemu_mallocz(sizeof(CharDriverState));
3392 if (!chr)
3393 goto return_err;
3394 s = qemu_mallocz(sizeof(NetCharDriver));
3395 if (!s)
3396 goto return_err;
3397
3398 fd = socket(PF_INET, SOCK_DGRAM, 0);
3399 if (fd < 0) {
3400 perror("socket(PF_INET, SOCK_DGRAM)");
3401 goto return_err;
3402 }
3403
951f1351
FB		 3404 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3405 printf("Could not parse: %s\n", def);
3406 goto return_err;
0bab00f3
FB		 3407 }
3408
951f1351 3409 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
0bab00f3
FB		 3410 {
3411 perror("bind");
3412 goto return_err;
3413 }
3414
3415 s->fd = fd;
3416 s->bufcnt = 0;
3417 s->bufptr = 0;
3418 chr->opaque = s;
3419 chr->chr_write = udp_chr_write;
e5b0bc44 3420 chr->chr_update_read_handler = udp_chr_update_read_handler;
0bab00f3
FB		 3421 return chr;
3422
3423return_err:
3424 if (chr)
3425 free(chr);
3426 if (s)
3427 free(s);
3428 if (fd >= 0)
3429 closesocket(fd);
3430 return NULL;
3431}
3432
3433/***********************************************************/
3434/* TCP Net console */
3435
3436typedef struct {
0bab00f3
FB		 3437 int fd, listen_fd;
3438 int connected;
3439 int max_size;
951f1351 3440 int do_telnetopt;
e5b0bc44 3441 int do_nodelay;
ffd843bc 3442 int is_unix;
0bab00f3
FB		 3443} TCPCharDriver;
3444
3445static void tcp_chr_accept(void *opaque);
3446
3447static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3448{
3449 TCPCharDriver *s = chr->opaque;
3450 if (s->connected) {
3451 return send_all(s->fd, buf, len);
3452 } else {
3453 /* XXX: indicate an error ? */
3454 return len;
3455 }
3456}
3457
3458static int tcp_chr_read_poll(void *opaque)
3459{
3460 CharDriverState *chr = opaque;
3461 TCPCharDriver *s = chr->opaque;
3462 if (!s->connected)
3463 return 0;
e5b0bc44 3464 s->max_size = qemu_chr_can_read(chr);
0bab00f3
FB		 3465 return s->max_size;
3466}
3467
951f1351
FB		 3468#define IAC 255
3469#define IAC_BREAK 243
3470static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3471 TCPCharDriver *s,
60fe76f3 3472 uint8_t *buf, int *size)
951f1351
FB		 3473{
3474 /* Handle any telnet client's basic IAC options to satisfy char by
3475 * char mode with no echo. All IAC options will be removed from
3476 * the buf and the do_telnetopt variable will be used to track the
3477 * state of the width of the IAC information.
3478 *
3479 * IAC commands come in sets of 3 bytes with the exception of the
3480 * "IAC BREAK" command and the double IAC.
3481 */
3482
3483 int i;
3484 int j = 0;
3485
3486 for (i = 0; i < *size; i++) {
3487 if (s->do_telnetopt > 1) {
3488 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3489 /* Double IAC means send an IAC */
3490 if (j != i)
3491 buf[j] = buf[i];
3492 j++;
3493 s->do_telnetopt = 1;
3494 } else {
3495 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3496 /* Handle IAC break commands by sending a serial break */
e5b0bc44 3497 qemu_chr_event(chr, CHR_EVENT_BREAK);
951f1351
FB		 3498 s->do_telnetopt++;
3499 }
3500 s->do_telnetopt++;
3501 }
3502 if (s->do_telnetopt >= 4) {
3503 s->do_telnetopt = 1;
3504 }
3505 } else {
3506 if ((unsigned char)buf[i] == IAC) {
3507 s->do_telnetopt = 2;
3508 } else {
3509 if (j != i)
3510 buf[j] = buf[i];
3511 j++;
3512 }
3513 }
3514 }
3515 *size = j;
3516}
3517
0bab00f3
FB		 3518static void tcp_chr_read(void *opaque)
3519{
3520 CharDriverState *chr = opaque;
3521 TCPCharDriver *s = chr->opaque;
3522 uint8_t buf[1024];
3523 int len, size;
3524
3525 if (!s->connected || s->max_size <= 0)
3526 return;
3527 len = sizeof(buf);
3528 if (len > s->max_size)
3529 len = s->max_size;
3530 size = recv(s->fd, buf, len, 0);
3531 if (size == 0) {
3532 /* connection closed */
3533 s->connected = 0;
3534 if (s->listen_fd >= 0) {
3535 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3536 }
3537 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3538 closesocket(s->fd);
3539 s->fd = -1;
3540 } else if (size > 0) {
951f1351
FB		 3541 if (s->do_telnetopt)
3542 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3543 if (size > 0)
e5b0bc44 3544 qemu_chr_read(chr, buf, size);
0bab00f3
FB		 3545 }
3546}
3547
0bab00f3
FB		 3548static void tcp_chr_connect(void *opaque)
3549{
3550 CharDriverState *chr = opaque;
3551 TCPCharDriver *s = chr->opaque;
3552
3553 s->connected = 1;
3554 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3555 tcp_chr_read, NULL, chr);
86e94dea 3556 qemu_chr_reset(chr);
0bab00f3
FB		 3557}
3558
951f1351
FB		 3559#define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3560static void tcp_chr_telnet_init(int fd)
3561{
3562 char buf[3];
3563 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3564 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3565 send(fd, (char *)buf, 3, 0);
3566 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3567 send(fd, (char *)buf, 3, 0);
3568 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3569 send(fd, (char *)buf, 3, 0);
3570 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3571 send(fd, (char *)buf, 3, 0);
3572}
3573
f7499989
PB		 3574static void socket_set_nodelay(int fd)
3575{
3576 int val = 1;
3577 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3578}
3579
0bab00f3
FB		 3580static void tcp_chr_accept(void *opaque)
3581{
3582 CharDriverState *chr = opaque;
3583 TCPCharDriver *s = chr->opaque;
3584 struct sockaddr_in saddr;
ffd843bc
TS		 3585#ifndef _WIN32
3586 struct sockaddr_un uaddr;
3587#endif
3588 struct sockaddr *addr;
0bab00f3
FB		 3589 socklen_t len;
3590 int fd;
3591
3592 for(;;) {
ffd843bc
TS		 3593#ifndef _WIN32
3594 if (s->is_unix) {
3595 len = sizeof(uaddr);
3596 addr = (struct sockaddr *)&uaddr;
3597 } else
3598#endif
3599 {
3600 len = sizeof(saddr);
3601 addr = (struct sockaddr *)&saddr;
3602 }
3603 fd = accept(s->listen_fd, addr, &len);
0bab00f3
FB		 3604 if (fd < 0 && errno != EINTR) {
3605 return;
3606 } else if (fd >= 0) {
951f1351
FB		 3607 if (s->do_telnetopt)
3608 tcp_chr_telnet_init(fd);
0bab00f3
FB		 3609 break;
3610 }
3611 }
3612 socket_set_nonblock(fd);
f7499989
PB		 3613 if (s->do_nodelay)
3614 socket_set_nodelay(fd);
0bab00f3
FB		 3615 s->fd = fd;
3616 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3617 tcp_chr_connect(chr);
3618}
3619
3620static void tcp_chr_close(CharDriverState *chr)
3621{
3622 TCPCharDriver *s = chr->opaque;
3623 if (s->fd >= 0)
3624 closesocket(s->fd);
3625 if (s->listen_fd >= 0)
3626 closesocket(s->listen_fd);
3627 qemu_free(s);
3628}
3629
5fafdf24 3630static CharDriverState *qemu_chr_open_tcp(const char *host_str,
ffd843bc
TS		 3631 int is_telnet,
3632 int is_unix)
0bab00f3
FB		 3633{
3634 CharDriverState *chr = NULL;
3635 TCPCharDriver *s = NULL;
3636 int fd = -1, ret, err, val;
951f1351
FB		 3637 int is_listen = 0;
3638 int is_waitconnect = 1;
f7499989 3639 int do_nodelay = 0;
951f1351 3640 const char *ptr;
0bab00f3 3641 struct sockaddr_in saddr;
ffd843bc
TS		 3642#ifndef _WIN32
3643 struct sockaddr_un uaddr;
3644#endif
3645 struct sockaddr *addr;
3646 socklen_t addrlen;
0bab00f3 3647
ffd843bc
TS		 3648#ifndef _WIN32
3649 if (is_unix) {
3650 addr = (struct sockaddr *)&uaddr;
3651 addrlen = sizeof(uaddr);
3652 if (parse_unix_path(&uaddr, host_str) < 0)
3653 goto fail;
3654 } else
3655#endif
3656 {
3657 addr = (struct sockaddr *)&saddr;
3658 addrlen = sizeof(saddr);
3659 if (parse_host_port(&saddr, host_str) < 0)
3660 goto fail;
3661 }
0bab00f3 3662
951f1351
FB		 3663 ptr = host_str;
3664 while((ptr = strchr(ptr,','))) {
3665 ptr++;
3666 if (!strncmp(ptr,"server",6)) {
3667 is_listen = 1;
3668 } else if (!strncmp(ptr,"nowait",6)) {
3669 is_waitconnect = 0;
f7499989
PB		 3670 } else if (!strncmp(ptr,"nodelay",6)) {
3671 do_nodelay = 1;
951f1351
FB		 3672 } else {
3673 printf("Unknown option: %s\n", ptr);
3674 goto fail;
3675 }
3676 }
3677 if (!is_listen)
3678 is_waitconnect = 0;
3679
0bab00f3
FB		 3680 chr = qemu_mallocz(sizeof(CharDriverState));
3681 if (!chr)
3682 goto fail;
3683 s = qemu_mallocz(sizeof(TCPCharDriver));
3684 if (!s)
3685 goto fail;
ffd843bc
TS		 3686
3687#ifndef _WIN32
3688 if (is_unix)
3689 fd = socket(PF_UNIX, SOCK_STREAM, 0);
3690 else
3691#endif
3692 fd = socket(PF_INET, SOCK_STREAM, 0);
5fafdf24
TS		 3693
3694 if (fd < 0)
0bab00f3 3695 goto fail;
951f1351
FB		 3696
3697 if (!is_waitconnect)
3698 socket_set_nonblock(fd);
0bab00f3
FB		 3699
3700 s->connected = 0;
3701 s->fd = -1;
3702 s->listen_fd = -1;
ffd843bc 3703 s->is_unix = is_unix;
f7499989 3704 s->do_nodelay = do_nodelay && !is_unix;
ffd843bc
TS		 3705
3706 chr->opaque = s;
3707 chr->chr_write = tcp_chr_write;
ffd843bc
TS		 3708 chr->chr_close = tcp_chr_close;
3709
0bab00f3
FB		 3710 if (is_listen) {
3711 /* allow fast reuse */
ffd843bc
TS		 3712#ifndef _WIN32
3713 if (is_unix) {
3714 char path[109];
ae45d369 3715 pstrcpy(path, sizeof(path), uaddr.sun_path);
ffd843bc
TS		 3716 unlink(path);
3717 } else
3718#endif
3719 {
3720 val = 1;
3721 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3722 }
3b46e624 3723
ffd843bc
TS		 3724 ret = bind(fd, addr, addrlen);
3725 if (ret < 0)
0bab00f3 3726 goto fail;
ffd843bc 3727
0bab00f3
FB		 3728 ret = listen(fd, 0);
3729 if (ret < 0)
3730 goto fail;
ffd843bc 3731
0bab00f3
FB		 3732 s->listen_fd = fd;
3733 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
951f1351
FB		 3734 if (is_telnet)
3735 s->do_telnetopt = 1;
0bab00f3
FB		 3736 } else {
3737 for(;;) {
ffd843bc 3738 ret = connect(fd, addr, addrlen);
0bab00f3
FB		 3739 if (ret < 0) {
3740 err = socket_error();
3741 if (err == EINTR || err == EWOULDBLOCK) {
3742 } else if (err == EINPROGRESS) {
3743 break;
f5b12268
TS		 3744#ifdef _WIN32
3745 } else if (err == WSAEALREADY) {
3746 break;
3747#endif
0bab00f3
FB		 3748 } else {
3749 goto fail;
3750 }
3751 } else {
3752 s->connected = 1;
3753 break;
3754 }
3755 }
3756 s->fd = fd;
f7499989 3757 socket_set_nodelay(fd);
0bab00f3
FB		 3758 if (s->connected)
3759 tcp_chr_connect(chr);
3760 else
3761 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3762 }
3b46e624 3763
951f1351
FB		 3764 if (is_listen && is_waitconnect) {
3765 printf("QEMU waiting for connection on: %s\n", host_str);
3766 tcp_chr_accept(chr);
3767 socket_set_nonblock(s->listen_fd);
3768 }
3769
0bab00f3
FB		 3770 return chr;
3771 fail:
3772 if (fd >= 0)
3773 closesocket(fd);
3774 qemu_free(s);
3775 qemu_free(chr);
3776 return NULL;
3777}
3778
82c643ff
FB		 3779CharDriverState *qemu_chr_open(const char *filename)
3780{
f8d179e3 3781 const char *p;
fd1dff4b 3782
82c643ff 3783 if (!strcmp(filename, "vc")) {
af3a9031
TS		 3784 return text_console_init(&display_state, 0);
3785 } else if (strstart(filename, "vc:", &p)) {
3786 return text_console_init(&display_state, p);
82c643ff
FB		 3787 } else if (!strcmp(filename, "null")) {
3788 return qemu_chr_open_null();
5fafdf24 3789 } else
0bab00f3 3790 if (strstart(filename, "tcp:", &p)) {
ffd843bc 3791 return qemu_chr_open_tcp(p, 0, 0);
0bab00f3 3792 } else
951f1351 3793 if (strstart(filename, "telnet:", &p)) {
ffd843bc 3794 return qemu_chr_open_tcp(p, 1, 0);
0bab00f3
FB		 3795 } else
3796 if (strstart(filename, "udp:", &p)) {
3797 return qemu_chr_open_udp(p);
3798 } else
20d8a3ed
TS		 3799 if (strstart(filename, "mon:", &p)) {
3800 CharDriverState *drv = qemu_chr_open(p);
3801 if (drv) {
3802 drv = qemu_chr_open_mux(drv);
3803 monitor_init(drv, !nographic);
3804 return drv;
3805 }
3806 printf("Unable to open driver: %s\n", p);
3807 return 0;
3808 } else
7664728b 3809#ifndef _WIN32
ffd843bc
TS		 3810 if (strstart(filename, "unix:", &p)) {
3811 return qemu_chr_open_tcp(p, 0, 1);
3812 } else if (strstart(filename, "file:", &p)) {
f8d179e3
FB		 3813 return qemu_chr_open_file_out(p);
3814 } else if (strstart(filename, "pipe:", &p)) {
3815 return qemu_chr_open_pipe(p);
7664728b 3816 } else if (!strcmp(filename, "pty")) {
82c643ff
FB		 3817 return qemu_chr_open_pty();
3818 } else if (!strcmp(filename, "stdio")) {
3819 return qemu_chr_open_stdio();
5fafdf24 3820 } else
f8d179e3 3821#if defined(__linux__)
e57a8c0e
FB		 3822 if (strstart(filename, "/dev/parport", NULL)) {
3823 return qemu_chr_open_pp(filename);
5fafdf24 3824 } else
aec62507 3825#endif
9892fbfb
BS		 3826#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3827 || defined(__NetBSD__) || defined(__OpenBSD__)
f8d179e3
FB		 3828 if (strstart(filename, "/dev/", NULL)) {
3829 return qemu_chr_open_tty(filename);
3fda388a
TS		 3830 } else
3831#endif
aec62507 3832#else /* !_WIN32 */
f331110f
FB		 3833 if (strstart(filename, "COM", NULL)) {
3834 return qemu_chr_open_win(filename);
3835 } else
3836 if (strstart(filename, "pipe:", &p)) {
3837 return qemu_chr_open_win_pipe(p);
3838 } else
72d46479
TS		 3839 if (strstart(filename, "con:", NULL)) {
3840 return qemu_chr_open_win_con(filename);
3841 } else
f331110f
FB		 3842 if (strstart(filename, "file:", &p)) {
3843 return qemu_chr_open_win_file_out(p);
2e4d9fb1
AJ		 3844 } else
3845#endif
3846#ifdef CONFIG_BRLAPI
3847 if (!strcmp(filename, "braille")) {
3848 return chr_baum_init();
3849 } else
82c643ff
FB		 3850#endif
3851 {
3852 return NULL;
3853 }
3854}
3855
f331110f
FB		 3856void qemu_chr_close(CharDriverState *chr)
3857{
3858 if (chr->chr_close)
3859 chr->chr_close(chr);
a11d070e 3860 qemu_free(chr);
f331110f
FB		 3861}
3862
80cabfad 3863/***********************************************************/
7c9d8e07 3864/* network device redirectors */
330d0414 3865
9dc63a1e 3866#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
9596ebb7 3867static void hex_dump(FILE *f, const uint8_t *buf, int size)
c20709aa
FB		 3868{
3869 int len, i, j, c;
3870
3871 for(i=0;i<size;i+=16) {
3872 len = size - i;
3873 if (len > 16)
3874 len = 16;
3875 fprintf(f, "%08x ", i);
3876 for(j=0;j<16;j++) {
3877 if (j < len)
3878 fprintf(f, " %02x", buf[i+j]);
3879 else
3880 fprintf(f, " ");
3881 }
3882 fprintf(f, " ");
3883 for(j=0;j<len;j++) {
3884 c = buf[i+j];
3885 if (c < ' ' || c > '~')
3886 c = '.';
3887 fprintf(f, "%c", c);
3888 }
3889 fprintf(f, "\n");
3890 }
3891}
9dc63a1e 3892#endif
c20709aa 3893
7c9d8e07 3894static int parse_macaddr(uint8_t *macaddr, const char *p)
c20709aa 3895{
7c9d8e07 3896 int i;
76ea08f9
AZ		 3897 char *last_char;
3898 long int offset;
3899
3900 errno = 0;
3901 offset = strtol(p, &last_char, 0);
3902 if (0 == errno && '\0' == *last_char &&
3903 offset >= 0 && offset <= 0xFFFFFF) {
3904 macaddr[3] = (offset & 0xFF0000) >> 16;
3905 macaddr[4] = (offset & 0xFF00) >> 8;
3906 macaddr[5] = offset & 0xFF;
3907 return 0;
3908 } else {
3909 for(i = 0; i < 6; i++) {
3910 macaddr[i] = strtol(p, (char **)&p, 16);
3911 if (i == 5) {
3912 if (*p != '\0')
3913 return -1;
3914 } else {
3915 if (*p != ':' && *p != '-')
3916 return -1;
3917 p++;
3918 }
7c9d8e07 3919 }
76ea08f9 3920 return 0;
7c9d8e07 3921 }
76ea08f9
AZ		 3922
3923 return -1;
c20709aa 3924}
67b915a5 3925
7c9d8e07 3926static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
67b915a5 3927{
7c9d8e07
FB		 3928 const char *p, *p1;
3929 int len;
3930 p = *pp;
3931 p1 = strchr(p, sep);
3932 if (!p1)
3933 return -1;
3934 len = p1 - p;
3935 p1++;
3936 if (buf_size > 0) {
3937 if (len > buf_size - 1)
3938 len = buf_size - 1;
3939 memcpy(buf, p, len);
3940 buf[len] = '\0';
3941 }
3942 *pp = p1;
3943 return 0;
c20709aa
FB		 3944}
3945
951f1351
FB		 3946int parse_host_src_port(struct sockaddr_in *haddr,
3947 struct sockaddr_in *saddr,
3948 const char *input_str)
3949{
3950 char *str = strdup(input_str);
3951 char *host_str = str;
3952 char *src_str;
7ccfb2eb 3953 const char *src_str2;
951f1351
FB		 3954 char *ptr;
3955
3956 /*
3957 * Chop off any extra arguments at the end of the string which
3958 * would start with a comma, then fill in the src port information
3959 * if it was provided else use the "any address" and "any port".
3960 */
3961 if ((ptr = strchr(str,',')))
3962 *ptr = '\0';
3963
3964 if ((src_str = strchr(input_str,'@'))) {
3965 *src_str = '\0';
3966 src_str++;
3967 }
3968
3969 if (parse_host_port(haddr, host_str) < 0)
3970 goto fail;
3971
7ccfb2eb 3972 src_str2 = src_str;
951f1351 3973 if (!src_str || *src_str == '\0')
7ccfb2eb 3974 src_str2 = ":0";
951f1351 3975
7ccfb2eb 3976 if (parse_host_port(saddr, src_str2) < 0)
951f1351
FB		 3977 goto fail;
3978
3979 free(str);
3980 return(0);
3981
3982fail:
3983 free(str);
3984 return -1;
3985}
3986
7c9d8e07
FB		 3987int parse_host_port(struct sockaddr_in *saddr, const char *str)
3988{
3989 char buf[512];
3990 struct hostent *he;
3991 const char *p, *r;
3992 int port;
3993
3994 p = str;
3995 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3996 return -1;
3997 saddr->sin_family = AF_INET;
3998 if (buf[0] == '\0') {
3999 saddr->sin_addr.s_addr = 0;
4000 } else {
4001 if (isdigit(buf[0])) {
4002 if (!inet_aton(buf, &saddr->sin_addr))
4003 return -1;
4004 } else {
7c9d8e07
FB		 4005 if ((he = gethostbyname(buf)) == NULL)
4006 return - 1;
4007 saddr->sin_addr = *(struct in_addr *)he->h_addr;
7c9d8e07
FB		 4008 }
4009 }
4010 port = strtol(p, (char **)&r, 0);
4011 if (r == p)
4012 return -1;
4013 saddr->sin_port = htons(port);
4014 return 0;
4015}
c20709aa 4016
52f61fde
TS		 4017#ifndef _WIN32
4018static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
ffd843bc
TS		 4019{
4020 const char *p;
4021 int len;
4022
4023 len = MIN(108, strlen(str));
4024 p = strchr(str, ',');
4025 if (p)
4026 len = MIN(len, p - str);
4027
4028 memset(uaddr, 0, sizeof(*uaddr));
4029
4030 uaddr->sun_family = AF_UNIX;
4031 memcpy(uaddr->sun_path, str, len);
4032
4033 return 0;
4034}
52f61fde 4035#endif
ffd843bc 4036
7c9d8e07
FB		 4037/* find or alloc a new VLAN */
4038VLANState *qemu_find_vlan(int id)
c20709aa 4039{
7c9d8e07
FB		 4040 VLANState **pvlan, *vlan;
4041 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4042 if (vlan->id == id)
4043 return vlan;
4044 }
4045 vlan = qemu_mallocz(sizeof(VLANState));
4046 if (!vlan)
4047 return NULL;
4048 vlan->id = id;
4049 vlan->next = NULL;
4050 pvlan = &first_vlan;
4051 while (*pvlan != NULL)
4052 pvlan = &(*pvlan)->next;
4053 *pvlan = vlan;
4054 return vlan;
c20709aa
FB		 4055}
4056
7c9d8e07 4057VLANClientState *qemu_new_vlan_client(VLANState *vlan,
d861b05e
PB		 4058 IOReadHandler *fd_read,
4059 IOCanRWHandler *fd_can_read,
4060 void *opaque)
c20709aa 4061{
7c9d8e07
FB		 4062 VLANClientState *vc, **pvc;
4063 vc = qemu_mallocz(sizeof(VLANClientState));
4064 if (!vc)
4065 return NULL;
4066 vc->fd_read = fd_read;
d861b05e 4067 vc->fd_can_read = fd_can_read;
7c9d8e07
FB		 4068 vc->opaque = opaque;
4069 vc->vlan = vlan;
4070
4071 vc->next = NULL;
4072 pvc = &vlan->first_client;
4073 while (*pvc != NULL)
4074 pvc = &(*pvc)->next;
4075 *pvc = vc;
4076 return vc;
c20709aa
FB		 4077}
4078
dcf414d6
AZ		 4079void qemu_del_vlan_client(VLANClientState *vc)
4080{
4081 VLANClientState **pvc = &vc->vlan->first_client;
4082
4083 while (*pvc != NULL)
4084 if (*pvc == vc) {
4085 *pvc = vc->next;
4086 free(vc);
4087 break;
4088 } else
4089 pvc = &(*pvc)->next;
4090}
4091
d861b05e
PB		 4092int qemu_can_send_packet(VLANClientState *vc1)
4093{
4094 VLANState *vlan = vc1->vlan;
4095 VLANClientState *vc;
4096
4097 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4098 if (vc != vc1) {
fbd1711d
AZ		 4099 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
4100 return 1;
d861b05e
PB		 4101 }
4102 }
fbd1711d 4103 return 0;
d861b05e
PB		 4104}
4105
7c9d8e07 4106void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
c20709aa 4107{
7c9d8e07
FB		 4108 VLANState *vlan = vc1->vlan;
4109 VLANClientState *vc;
4110
9dc63a1e 4111#ifdef DEBUG_NET
7c9d8e07
FB		 4112 printf("vlan %d send:\n", vlan->id);
4113 hex_dump(stdout, buf, size);
4114#endif
4115 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
4116 if (vc != vc1) {
4117 vc->fd_read(vc->opaque, buf, size);
4118 }
4119 }
67b915a5
FB		 4120}
4121
c20709aa
FB		 4122#if defined(CONFIG_SLIRP)
4123
4124/* slirp network adapter */
4125
c20709aa 4126static int slirp_inited;
7c9d8e07 4127static VLANClientState *slirp_vc;
c20709aa
FB		 4128
4129int slirp_can_output(void)
4130{
3b7f5d47 4131 return !slirp_vc || qemu_can_send_packet(slirp_vc);
c20709aa
FB		 4132}
4133
4134void slirp_output(const uint8_t *pkt, int pkt_len)
67b915a5 4135{
9dc63a1e 4136#ifdef DEBUG_SLIRP
7c9d8e07 4137 printf("slirp output:\n");
c20709aa
FB		 4138 hex_dump(stdout, pkt, pkt_len);
4139#endif
3b7f5d47
PB		 4140 if (!slirp_vc)
4141 return;
7c9d8e07 4142 qemu_send_packet(slirp_vc, pkt, pkt_len);
67b915a5
FB		 4143}
4144
7c9d8e07 4145static void slirp_receive(void *opaque, const uint8_t *buf, int size)
c20709aa 4146{
9dc63a1e 4147#ifdef DEBUG_SLIRP
7c9d8e07 4148 printf("slirp input:\n");
c20709aa
FB		 4149 hex_dump(stdout, buf, size);
4150#endif
4151 slirp_input(buf, size);
4152}
4153
7c9d8e07 4154static int net_slirp_init(VLANState *vlan)
c20709aa
FB		 4155{
4156 if (!slirp_inited) {
4157 slirp_inited = 1;
4158 slirp_init();
4159 }
5fafdf24 4160 slirp_vc = qemu_new_vlan_client(vlan,
d861b05e 4161 slirp_receive, NULL, NULL);
7c9d8e07 4162 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
9bf05444
FB		 4163 return 0;
4164}
4165
4166static void net_slirp_redir(const char *redir_str)
4167{
4168 int is_udp;
4169 char buf[256], *r;
4170 const char *p;
4171 struct in_addr guest_addr;
4172 int host_port, guest_port;
3b46e624 4173
9bf05444
FB		 4174 if (!slirp_inited) {
4175 slirp_inited = 1;
4176 slirp_init();
4177 }
4178
4179 p = redir_str;
4180 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4181 goto fail;
4182 if (!strcmp(buf, "tcp")) {
4183 is_udp = 0;
4184 } else if (!strcmp(buf, "udp")) {
4185 is_udp = 1;
4186 } else {
4187 goto fail;
4188 }
4189
4190 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4191 goto fail;
4192 host_port = strtol(buf, &r, 0);
4193 if (r == buf)
4194 goto fail;
4195
4196 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
4197 goto fail;
4198 if (buf[0] == '\0') {
4199 pstrcpy(buf, sizeof(buf), "10.0.2.15");
4200 }
4201 if (!inet_aton(buf, &guest_addr))
4202 goto fail;
3b46e624 4203
9bf05444
FB		 4204 guest_port = strtol(p, &r, 0);
4205 if (r == p)
4206 goto fail;
3b46e624 4207
9bf05444
FB		 4208 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
4209 fprintf(stderr, "qemu: could not set up redirection\n");
4210 exit(1);
4211 }
4212 return;
4213 fail:
4214 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4215 exit(1);
4216}
3b46e624 4217
c94c8d64
FB		 4218#ifndef _WIN32
4219
dbed7e40 4220static char smb_dir[1024];
9d728e8c 4221
044fae83 4222static void erase_dir(char *dir_name)
9d728e8c
FB		 4223{
4224 DIR *d;
4225 struct dirent *de;
4226 char filename[1024];
4227
4228 /* erase all the files in the directory */
044fae83
AZ		 4229 if ((d = opendir(dir_name)) != 0) {
4230 for(;;) {
4231 de = readdir(d);
4232 if (!de)
4233 break;
4234 if (strcmp(de->d_name, ".") != 0 &&
4235 strcmp(de->d_name, "..") != 0) {
4236 snprintf(filename, sizeof(filename), "%s/%s",
4237 smb_dir, de->d_name);
4238 if (unlink(filename) != 0) /* is it a directory? */
4239 erase_dir(filename);
4240 }
9d728e8c 4241 }
044fae83
AZ		 4242 closedir(d);
4243 rmdir(dir_name);
9d728e8c 4244 }
044fae83
AZ		 4245}
4246
4247/* automatic user mode samba server configuration */
4248static void smb_exit(void)
4249{
4250 erase_dir(smb_dir);
9d728e8c
FB		 4251}
4252
4253/* automatic user mode samba server configuration */
9596ebb7 4254static void net_slirp_smb(const char *exported_dir)
9d728e8c
FB		 4255{
4256 char smb_conf[1024];
4257 char smb_cmdline[1024];
4258 FILE *f;
4259
4260 if (!slirp_inited) {
4261 slirp_inited = 1;
4262 slirp_init();
4263 }
4264
4265 /* XXX: better tmp dir construction */
4266 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
4267 if (mkdir(smb_dir, 0700) < 0) {
4268 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
4269 exit(1);
4270 }
4271 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3b46e624 4272
9d728e8c
FB		 4273 f = fopen(smb_conf, "w");
4274 if (!f) {
4275 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
4276 exit(1);
4277 }
5fafdf24 4278 fprintf(f,
9d728e8c 4279 "[global]\n"
157777ef
FB		 4280 "private dir=%s\n"
4281 "smb ports=0\n"
4282 "socket address=127.0.0.1\n"
9d728e8c
FB		 4283 "pid directory=%s\n"
4284 "lock directory=%s\n"
4285 "log file=%s/log.smbd\n"
4286 "smb passwd file=%s/smbpasswd\n"
03ffbb69 4287 "security = share\n"
9d728e8c
FB		 4288 "[qemu]\n"
4289 "path=%s\n"
4290 "read only=no\n"
4291 "guest ok=yes\n",
4292 smb_dir,
157777ef 4293 smb_dir,
9d728e8c
FB		 4294 smb_dir,
4295 smb_dir,
4296 smb_dir,
4297 exported_dir
4298 );
4299 fclose(f);
4300 atexit(smb_exit);
4301
a14d6c8c
PB		 4302 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
4303 SMBD_COMMAND, smb_conf);
3b46e624 4304
9d728e8c
FB		 4305 slirp_add_exec(0, smb_cmdline, 4, 139);
4306}
9bf05444 4307
c94c8d64 4308#endif /* !defined(_WIN32) */
31a60e22
BS		 4309void do_info_slirp(void)
4310{
4311 slirp_stats();
4312}
c94c8d64 4313
c20709aa
FB		 4314#endif /* CONFIG_SLIRP */
4315
4316#if !defined(_WIN32)
7c9d8e07
FB		 4317
4318typedef struct TAPState {
4319 VLANClientState *vc;
4320 int fd;
b46a8906 4321 char down_script[1024];
7c9d8e07
FB		 4322} TAPState;
4323
4324static void tap_receive(void *opaque, const uint8_t *buf, int size)
4325{
4326 TAPState *s = opaque;
4327 int ret;
4328 for(;;) {
4329 ret = write(s->fd, buf, size);
4330 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
4331 } else {
4332 break;
4333 }
4334 }
4335}
4336
4337static void tap_send(void *opaque)
4338{
4339 TAPState *s = opaque;
4340 uint8_t buf[4096];
4341 int size;
4342
d5d10bc3
TS		 4343#ifdef __sun__
4344 struct strbuf sbuf;
4345 int f = 0;
4346 sbuf.maxlen = sizeof(buf);
4347 sbuf.buf = buf;
4348 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
4349#else
7c9d8e07 4350 size = read(s->fd, buf, sizeof(buf));
d5d10bc3 4351#endif
7c9d8e07
FB		 4352 if (size > 0) {
4353 qemu_send_packet(s->vc, buf, size);
4354 }
4355}
4356
4357/* fd support */
4358
4359static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
4360{
4361 TAPState *s;
4362
4363 s = qemu_mallocz(sizeof(TAPState));
4364 if (!s)
4365 return NULL;
4366 s->fd = fd;
d861b05e 4367 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
7c9d8e07
FB		 4368 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
4369 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
4370 return s;
4371}
4372
5c40d2bd 4373#if defined (_BSD) || defined (__FreeBSD_kernel__)
7c9d8e07 4374static int tap_open(char *ifname, int ifname_size)
7d3505c5
FB		 4375{
4376 int fd;
4377 char *dev;
4378 struct stat s;
67b915a5 4379
aeb30be6 4380 TFR(fd = open("/dev/tap", O_RDWR));
7d3505c5
FB		 4381 if (fd < 0) {
4382 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4383 return -1;
4384 }
4385
4386 fstat(fd, &s);
4387 dev = devname(s.st_rdev, S_IFCHR);
4388 pstrcpy(ifname, ifname_size, dev);
4389
4390 fcntl(fd, F_SETFL, O_NONBLOCK);
4391 return fd;
4392}
ec530c81 4393#elif defined(__sun__)
d5d10bc3 4394#define TUNNEWPPA (('T'<<16) | 0x0001)
5fafdf24
TS		 4395/*
4396 * Allocate TAP device, returns opened fd.
d5d10bc3 4397 * Stores dev name in the first arg(must be large enough).
3b46e624 4398 */
363a37d5 4399int tap_alloc(char *dev, size_t dev_size)
d5d10bc3
TS		 4400{
4401 int tap_fd, if_fd, ppa = -1;
4402 static int ip_fd = 0;
4403 char *ptr;
4404
4405 static int arp_fd = 0;
4406 int ip_muxid, arp_muxid;
4407 struct strioctl strioc_if, strioc_ppa;
4408 int link_type = I_PLINK;;
4409 struct lifreq ifr;
4410 char actual_name[32] = "";
4411
4412 memset(&ifr, 0x0, sizeof(ifr));
4413
4414 if( *dev ){
5fafdf24
TS		 4415 ptr = dev;
4416 while( *ptr && !isdigit((int)*ptr) ) ptr++;
d5d10bc3
TS		 4417 ppa = atoi(ptr);
4418 }
4419
4420 /* Check if IP device was opened */
4421 if( ip_fd )
4422 close(ip_fd);
4423
aeb30be6
AZ		 4424 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4425 if (ip_fd < 0) {
d5d10bc3
TS		 4426 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4427 return -1;
4428 }
4429
aeb30be6
AZ		 4430 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4431 if (tap_fd < 0) {
d5d10bc3
TS		 4432 syslog(LOG_ERR, "Can't open /dev/tap");
4433 return -1;
4434 }
4435
4436 /* Assign a new PPA and get its unit number. */
4437 strioc_ppa.ic_cmd = TUNNEWPPA;
4438 strioc_ppa.ic_timout = 0;
4439 strioc_ppa.ic_len = sizeof(ppa);
4440 strioc_ppa.ic_dp = (char *)&ppa;
4441 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4442 syslog (LOG_ERR, "Can't assign new interface");
4443
aeb30be6
AZ		 4444 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4445 if (if_fd < 0) {
d5d10bc3
TS		 4446 syslog(LOG_ERR, "Can't open /dev/tap (2)");
4447 return -1;
4448 }
4449 if(ioctl(if_fd, I_PUSH, "ip") < 0){
4450 syslog(LOG_ERR, "Can't push IP module");
4451 return -1;
4452 }
4453
4454 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4455 syslog(LOG_ERR, "Can't get flags\n");
4456
4457 snprintf (actual_name, 32, "tap%d", ppa);
4458 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4459
4460 ifr.lifr_ppa = ppa;
4461 /* Assign ppa according to the unit number returned by tun device */
4462
4463 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4464 syslog (LOG_ERR, "Can't set PPA %d", ppa);
4465 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4466 syslog (LOG_ERR, "Can't get flags\n");
4467 /* Push arp module to if_fd */
4468 if (ioctl (if_fd, I_PUSH, "arp") < 0)
4469 syslog (LOG_ERR, "Can't push ARP module (2)");
4470
4471 /* Push arp module to ip_fd */
4472 if (ioctl (ip_fd, I_POP, NULL) < 0)
4473 syslog (LOG_ERR, "I_POP failed\n");
4474 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4475 syslog (LOG_ERR, "Can't push ARP module (3)\n");
4476 /* Open arp_fd */
aeb30be6
AZ		 4477 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4478 if (arp_fd < 0)
d5d10bc3
TS		 4479 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4480
4481 /* Set ifname to arp */
4482 strioc_if.ic_cmd = SIOCSLIFNAME;
4483 strioc_if.ic_timout = 0;
4484 strioc_if.ic_len = sizeof(ifr);
4485 strioc_if.ic_dp = (char *)&ifr;
4486 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4487 syslog (LOG_ERR, "Can't set ifname to arp\n");
4488 }
4489
4490 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4491 syslog(LOG_ERR, "Can't link TAP device to IP");
4492 return -1;
4493 }
4494
4495 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4496 syslog (LOG_ERR, "Can't link TAP device to ARP");
4497
4498 close (if_fd);
4499
4500 memset(&ifr, 0x0, sizeof(ifr));
4501 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4502 ifr.lifr_ip_muxid = ip_muxid;
4503 ifr.lifr_arp_muxid = arp_muxid;
4504
4505 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4506 {
4507 ioctl (ip_fd, I_PUNLINK , arp_muxid);
4508 ioctl (ip_fd, I_PUNLINK, ip_muxid);
4509 syslog (LOG_ERR, "Can't set multiplexor id");
4510 }
4511
363a37d5 4512 snprintf(dev, dev_size, "tap%d", ppa);
d5d10bc3
TS		 4513 return tap_fd;
4514}
4515
ec530c81
FB		 4516static int tap_open(char *ifname, int ifname_size)
4517{
d5d10bc3
TS		 4518 char dev[10]="";
4519 int fd;
363a37d5 4520 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
d5d10bc3
TS		 4521 fprintf(stderr, "Cannot allocate TAP device\n");
4522 return -1;
4523 }
4524 pstrcpy(ifname, ifname_size, dev);
4525 fcntl(fd, F_SETFL, O_NONBLOCK);
4526 return fd;
ec530c81 4527}
7d3505c5 4528#else
7c9d8e07 4529static int tap_open(char *ifname, int ifname_size)
330d0414 4530{
80cabfad 4531 struct ifreq ifr;
c4b1fcc0 4532 int fd, ret;
3b46e624 4533
aeb30be6 4534 TFR(fd = open("/dev/net/tun", O_RDWR));
80cabfad
FB		 4535 if (fd < 0) {
4536 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4537 return -1;
330d0414 4538 }
80cabfad
FB		 4539 memset(&ifr, 0, sizeof(ifr));
4540 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
7c9d8e07
FB		 4541 if (ifname[0] != '\0')
4542 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4543 else
4544 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
80cabfad
FB		 4545 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4546 if (ret != 0) {
4547 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4548 close(fd);
4549 return -1;
4550 }
c4b1fcc0 4551 pstrcpy(ifname, ifname_size, ifr.ifr_name);
80cabfad 4552 fcntl(fd, F_SETFL, O_NONBLOCK);
c4b1fcc0
FB		 4553 return fd;
4554}
7d3505c5 4555#endif
330d0414 4556
b46a8906 4557static int launch_script(const char *setup_script, const char *ifname, int fd)
7c9d8e07 4558{
b46a8906 4559 int pid, status;
7c9d8e07
FB		 4560 char *args[3];
4561 char **parg;
7c9d8e07 4562
b46a8906 4563 /* try to launch network script */
7c9d8e07
FB		 4564 pid = fork();
4565 if (pid >= 0) {
4566 if (pid == 0) {
50d3eeae
TS		 4567 int open_max = sysconf (_SC_OPEN_MAX), i;
4568 for (i = 0; i < open_max; i++)
4569 if (i != STDIN_FILENO &&
4570 i != STDOUT_FILENO &&
4571 i != STDERR_FILENO &&
4572 i != fd)
4573 close(i);
4574
7c9d8e07
FB		 4575 parg = args;
4576 *parg++ = (char *)setup_script;
b46a8906 4577 *parg++ = (char *)ifname;
7c9d8e07
FB		 4578 *parg++ = NULL;
4579 execv(setup_script, args);
4a38940d 4580 _exit(1);
7c9d8e07
FB		 4581 }
4582 while (waitpid(pid, &status, 0) != pid);
4583 if (!WIFEXITED(status) ||
4584 WEXITSTATUS(status) != 0) {
4585 fprintf(stderr, "%s: could not launch network script\n",
4586 setup_script);
4587 return -1;
4588 }
4589 }
b46a8906
TS		 4590 return 0;
4591}
4592
4593static int net_tap_init(VLANState *vlan, const char *ifname1,
4594 const char *setup_script, const char *down_script)
4595{
4596 TAPState *s;
4597 int fd;
4598 char ifname[128];
4599
4600 if (ifname1 != NULL)
4601 pstrcpy(ifname, sizeof(ifname), ifname1);
4602 else
4603 ifname[0] = '\0';
4604 TFR(fd = tap_open(ifname, sizeof(ifname)));
4605 if (fd < 0)
4606 return -1;
4607
4608 if (!setup_script || !strcmp(setup_script, "no"))
4609 setup_script = "";
4610 if (setup_script[0] != '\0') {
4611 if (launch_script(setup_script, ifname, fd))
4612 return -1;
7c9d8e07
FB		 4613 }
4614 s = net_tap_fd_init(vlan, fd);
4615 if (!s)
4616 return -1;
5fafdf24 4617 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
7c9d8e07 4618 "tap: ifname=%s setup_script=%s", ifname, setup_script);
b46a8906
TS		 4619 if (down_script && strcmp(down_script, "no"))
4620 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
7c9d8e07
FB		 4621 return 0;
4622}
4623
fd1dff4b
FB		 4624#endif /* !_WIN32 */
4625
8a16d273
TS		 4626#if defined(CONFIG_VDE)
4627typedef struct VDEState {
4628 VLANClientState *vc;
4629 VDECONN *vde;
4630} VDEState;
4631
4632static void vde_to_qemu(void *opaque)
4633{
4634 VDEState *s = opaque;
4635 uint8_t buf[4096];
4636 int size;
4637
4638 size = vde_recv(s->vde, buf, sizeof(buf), 0);
4639 if (size > 0) {
4640 qemu_send_packet(s->vc, buf, size);
4641 }
4642}
4643
4644static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
4645{
4646 VDEState *s = opaque;
4647 int ret;
4648 for(;;) {
4649 ret = vde_send(s->vde, buf, size, 0);
4650 if (ret < 0 && errno == EINTR) {
4651 } else {
4652 break;
4653 }
4654 }
4655}
4656
4657static int net_vde_init(VLANState *vlan, const char *sock, int port,
4658 const char *group, int mode)
4659{
4660 VDEState *s;
4661 char *init_group = strlen(group) ? (char *)group : NULL;
4662 char *init_sock = strlen(sock) ? (char *)sock : NULL;
4663
4664 struct vde_open_args args = {
4665 .port = port,
4666 .group = init_group,
4667 .mode = mode,
4668 };
4669
4670 s = qemu_mallocz(sizeof(VDEState));
4671 if (!s)
4672 return -1;
4673 s->vde = vde_open(init_sock, "QEMU", &args);
4674 if (!s->vde){
4675 free(s);
4676 return -1;
4677 }
4678 s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
4679 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
4680 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
4681 sock, vde_datafd(s->vde));
4682 return 0;
4683}
4684#endif
4685
7c9d8e07
FB		 4686/* network connection */
4687typedef struct NetSocketState {
4688 VLANClientState *vc;
4689 int fd;
4690 int state; /* 0 = getting length, 1 = getting data */
4691 int index;
4692 int packet_len;
4693 uint8_t buf[4096];
3d830459 4694 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
7c9d8e07
FB		 4695} NetSocketState;
4696
4697typedef struct NetSocketListenState {
4698 VLANState *vlan;
4699 int fd;
4700} NetSocketListenState;
4701
4702/* XXX: we consider we can send the whole packet without blocking */
4703static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
c20709aa 4704{
7c9d8e07
FB		 4705 NetSocketState *s = opaque;
4706 uint32_t len;
4707 len = htonl(size);
4708
fd1dff4b
FB		 4709 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4710 send_all(s->fd, buf, size);
c20709aa
FB		 4711}
4712
3d830459
FB		 4713static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4714{
4715 NetSocketState *s = opaque;
5fafdf24 4716 sendto(s->fd, buf, size, 0,
3d830459
FB		 4717 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4718}
4719
7c9d8e07 4720static void net_socket_send(void *opaque)
c4b1fcc0 4721{
7c9d8e07 4722 NetSocketState *s = opaque;
fd1dff4b 4723 int l, size, err;
7c9d8e07
FB		 4724 uint8_t buf1[4096];
4725 const uint8_t *buf;
4726
fd1dff4b
FB		 4727 size = recv(s->fd, buf1, sizeof(buf1), 0);
4728 if (size < 0) {
4729 err = socket_error();
5fafdf24 4730 if (err != EWOULDBLOCK)
fd1dff4b
FB		 4731 goto eoc;
4732 } else if (size == 0) {
7c9d8e07 4733 /* end of connection */
fd1dff4b 4734 eoc:
7c9d8e07 4735 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
fd1dff4b 4736 closesocket(s->fd);
7c9d8e07
FB		 4737 return;
4738 }
4739 buf = buf1;
4740 while (size > 0) {
4741 /* reassemble a packet from the network */
4742 switch(s->state) {
4743 case 0:
4744 l = 4 - s->index;
4745 if (l > size)
4746 l = size;
4747 memcpy(s->buf + s->index, buf, l);
4748 buf += l;
4749 size -= l;
4750 s->index += l;
4751 if (s->index == 4) {
4752 /* got length */
4753 s->packet_len = ntohl(*(uint32_t *)s->buf);
4754 s->index = 0;
4755 s->state = 1;
4756 }
4757 break;
4758 case 1:
4759 l = s->packet_len - s->index;
4760 if (l > size)
4761 l = size;
4762 memcpy(s->buf + s->index, buf, l);
4763 s->index += l;
4764 buf += l;
4765 size -= l;
4766 if (s->index >= s->packet_len) {
4767 qemu_send_packet(s->vc, s->buf, s->packet_len);
4768 s->index = 0;
4769 s->state = 0;
4770 }
4771 break;
4772 }
4773 }
c20709aa
FB		 4774}
4775
3d830459
FB		 4776static void net_socket_send_dgram(void *opaque)
4777{
4778 NetSocketState *s = opaque;
4779 int size;
4780
4781 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
5fafdf24 4782 if (size < 0)
3d830459
FB		 4783 return;
4784 if (size == 0) {
4785 /* end of connection */
4786 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4787 return;
4788 }
4789 qemu_send_packet(s->vc, s->buf, size);
4790}
4791
4792static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4793{
4794 struct ip_mreq imr;
4795 int fd;
4796 int val, ret;
4797 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4798 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
5fafdf24 4799 inet_ntoa(mcastaddr->sin_addr),
fd1dff4b 4800 (int)ntohl(mcastaddr->sin_addr.s_addr));
3d830459
FB		 4801 return -1;
4802
4803 }
4804 fd = socket(PF_INET, SOCK_DGRAM, 0);
4805 if (fd < 0) {
4806 perror("socket(PF_INET, SOCK_DGRAM)");
4807 return -1;
4808 }
4809
fd1dff4b 4810 val = 1;
5fafdf24 4811 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
fd1dff4b
FB		 4812 (const char *)&val, sizeof(val));
4813 if (ret < 0) {
4814 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4815 goto fail;
4816 }
4817
4818 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4819 if (ret < 0) {
4820 perror("bind");
4821 goto fail;
4822 }
3b46e624 4823
3d830459
FB		 4824 /* Add host to multicast group */
4825 imr.imr_multiaddr = mcastaddr->sin_addr;
4826 imr.imr_interface.s_addr = htonl(INADDR_ANY);
4827
5fafdf24 4828 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
fd1dff4b 4829 (const char *)&imr, sizeof(struct ip_mreq));
3d830459
FB		 4830 if (ret < 0) {
4831 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4832 goto fail;
4833 }
4834
4835 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4836 val = 1;
5fafdf24 4837 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
fd1dff4b 4838 (const char *)&val, sizeof(val));
3d830459
FB		 4839 if (ret < 0) {
4840 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4841 goto fail;
4842 }
4843
fd1dff4b 4844 socket_set_nonblock(fd);
3d830459
FB		 4845 return fd;
4846fail:
5fafdf24 4847 if (fd >= 0)
0bab00f3 4848 closesocket(fd);
3d830459
FB		 4849 return -1;
4850}
4851
5fafdf24 4852static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
3d830459
FB		 4853 int is_connected)
4854{
4855 struct sockaddr_in saddr;
4856 int newfd;
4857 socklen_t saddr_len;
4858 NetSocketState *s;
4859
4860 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
5fafdf24 4861 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
3d830459
FB		 4862 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4863 */
4864
4865 if (is_connected) {
4866 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4867 /* must be bound */
4868 if (saddr.sin_addr.s_addr==0) {
4869 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4870 fd);
4871 return NULL;
4872 }
4873 /* clone dgram socket */
4874 newfd = net_socket_mcast_create(&saddr);
4875 if (newfd < 0) {
4876 /* error already reported by net_socket_mcast_create() */
4877 close(fd);
4878 return NULL;
4879 }
4880 /* clone newfd to fd, close newfd */
4881 dup2(newfd, fd);
4882 close(newfd);
5fafdf24 4883
3d830459
FB		 4884 } else {
4885 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4886 fd, strerror(errno));
4887 return NULL;
4888 }
4889 }
4890
4891 s = qemu_mallocz(sizeof(NetSocketState));
4892 if (!s)
4893 return NULL;
4894 s->fd = fd;
4895
d861b05e 4896 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
3d830459
FB		 4897 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4898
4899 /* mcast: save bound address as dst */
4900 if (is_connected) s->dgram_dst=saddr;
4901
4902 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5fafdf24 4903 "socket: fd=%d (%s mcast=%s:%d)",
3d830459
FB		 4904 fd, is_connected? "cloned" : "",
4905 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4906 return s;
4907}
4908
7c9d8e07 4909static void net_socket_connect(void *opaque)
c20709aa 4910{
7c9d8e07
FB		 4911 NetSocketState *s = opaque;
4912 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4913}
c4b1fcc0 4914
5fafdf24 4915static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
7c9d8e07
FB		 4916 int is_connected)
4917{
4918 NetSocketState *s;
4919 s = qemu_mallocz(sizeof(NetSocketState));
4920 if (!s)
4921 return NULL;
4922 s->fd = fd;
5fafdf24 4923 s->vc = qemu_new_vlan_client(vlan,
d861b05e 4924 net_socket_receive, NULL, s);
7c9d8e07
FB		 4925 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4926 "socket: fd=%d", fd);
4927 if (is_connected) {
4928 net_socket_connect(s);
4929 } else {
4930 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4931 }
4932 return s;
4933}
c4b1fcc0 4934
5fafdf24 4935static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
3d830459
FB		 4936 int is_connected)
4937{
4938 int so_type=-1, optlen=sizeof(so_type);
4939
69b34976
TS		 4940 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4941 (socklen_t *)&optlen)< 0) {
931f03ee 4942 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
3d830459
FB		 4943 return NULL;
4944 }
4945 switch(so_type) {
4946 case SOCK_DGRAM:
4947 return net_socket_fd_init_dgram(vlan, fd, is_connected);
4948 case SOCK_STREAM:
4949 return net_socket_fd_init_stream(vlan, fd, is_connected);
4950 default:
4951 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4952 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4953 return net_socket_fd_init_stream(vlan, fd, is_connected);
4954 }
4955 return NULL;
4956}
4957
7c9d8e07
FB		 4958static void net_socket_accept(void *opaque)
4959{
3b46e624 4960 NetSocketListenState *s = opaque;
7c9d8e07
FB		 4961 NetSocketState *s1;
4962 struct sockaddr_in saddr;
4963 socklen_t len;
4964 int fd;
4965
4966 for(;;) {
4967 len = sizeof(saddr);
4968 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4969 if (fd < 0 && errno != EINTR) {
4970 return;
4971 } else if (fd >= 0) {
4972 break;
80cabfad 4973 }
330d0414 4974 }
5fafdf24 4975 s1 = net_socket_fd_init(s->vlan, fd, 1);
7c9d8e07 4976 if (!s1) {
0bab00f3 4977 closesocket(fd);
7c9d8e07
FB		 4978 } else {
4979 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
5fafdf24 4980 "socket: connection from %s:%d",
7c9d8e07
FB		 4981 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4982 }
4983}
4984
4985static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4986{
4987 NetSocketListenState *s;
4988 int fd, val, ret;
4989 struct sockaddr_in saddr;
4990
4991 if (parse_host_port(&saddr, host_str) < 0)
4992 return -1;
3b46e624 4993
7c9d8e07
FB		 4994 s = qemu_mallocz(sizeof(NetSocketListenState));
4995 if (!s)
4996 return -1;
4997
4998 fd = socket(PF_INET, SOCK_STREAM, 0);
4999 if (fd < 0) {
5000 perror("socket");
5001 return -1;
5002 }
fd1dff4b 5003 socket_set_nonblock(fd);
7c9d8e07
FB		 5004
5005 /* allow fast reuse */
5006 val = 1;
fd1dff4b 5007 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3b46e624 5008
7c9d8e07
FB		 5009 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5010 if (ret < 0) {
5011 perror("bind");
5012 return -1;
5013 }
5014 ret = listen(fd, 0);
5015 if (ret < 0) {
5016 perror("listen");
5017 return -1;
5018 }
5019 s->vlan = vlan;
5020 s->fd = fd;
5021 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
80cabfad 5022 return 0;
330d0414
FB		 5023}
5024
7c9d8e07 5025static int net_socket_connect_init(VLANState *vlan, const char *host_str)
330d0414 5026{
7c9d8e07 5027 NetSocketState *s;
fd1dff4b 5028 int fd, connected, ret, err;
7c9d8e07
FB		 5029 struct sockaddr_in saddr;
5030
5031 if (parse_host_port(&saddr, host_str) < 0)
5032 return -1;
5033
5034 fd = socket(PF_INET, SOCK_STREAM, 0);
5035 if (fd < 0) {
5036 perror("socket");
5037 return -1;
5038 }
fd1dff4b 5039 socket_set_nonblock(fd);
7c9d8e07
FB		 5040
5041 connected = 0;
5042 for(;;) {
5043 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
5044 if (ret < 0) {
fd1dff4b
FB		 5045 err = socket_error();
5046 if (err == EINTR || err == EWOULDBLOCK) {
5047 } else if (err == EINPROGRESS) {
7c9d8e07 5048 break;
f5b12268
TS		 5049#ifdef _WIN32
5050 } else if (err == WSAEALREADY) {
5051 break;
5052#endif
7c9d8e07
FB		 5053 } else {
5054 perror("connect");
fd1dff4b 5055 closesocket(fd);
7c9d8e07
FB		 5056 return -1;
5057 }
5058 } else {
5059 connected = 1;
5060 break;
5061 }
5062 }
5063 s = net_socket_fd_init(vlan, fd, connected);
5064 if (!s)
5065 return -1;
5066 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5fafdf24 5067 "socket: connect to %s:%d",
7c9d8e07 5068 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
c20709aa 5069 return 0;
80cabfad 5070}
330d0414 5071
3d830459
FB		 5072static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
5073{
5074 NetSocketState *s;
5075 int fd;
5076 struct sockaddr_in saddr;
5077
5078 if (parse_host_port(&saddr, host_str) < 0)
5079 return -1;
5080
5081
5082 fd = net_socket_mcast_create(&saddr);
5083 if (fd < 0)
5084 return -1;
5085
5086 s = net_socket_fd_init(vlan, fd, 0);
5087 if (!s)
5088 return -1;
5089
5090 s->dgram_dst = saddr;
3b46e624 5091
3d830459 5092 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
5fafdf24 5093 "socket: mcast=%s:%d",
3d830459
FB		 5094 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
5095 return 0;
5096
5097}
5098
609497ab
AZ		 5099static const char *get_opt_name(char *buf, int buf_size, const char *p)
5100{
5101 char *q;
5102
5103 q = buf;
5104 while (*p != '\0' && *p != '=') {
5105 if (q && (q - buf) < buf_size - 1)
5106 *q++ = *p;
5107 p++;
5108 }
5109 if (q)
5110 *q = '\0';
5111
5112 return p;
5113}
5114
5115static const char *get_opt_value(char *buf, int buf_size, const char *p)
e4bcb14c
TS		 5116{
5117 char *q;
e4bcb14c 5118
e4bcb14c
TS		 5119 q = buf;
5120 while (*p != '\0') {
609497ab
AZ		 5121 if (*p == ',') {
5122 if (*(p + 1) != ',')
e4bcb14c 5123 break;
e4bcb14c 5124 p++;
609497ab 5125 }
e4bcb14c
TS		 5126 if (q && (q - buf) < buf_size - 1)
5127 *q++ = *p;
5128 p++;
5129 }
5130 if (q)
5131 *q = '\0';
5132
5133 return p;
5134}
5135
7c9d8e07
FB		 5136static int get_param_value(char *buf, int buf_size,
5137 const char *tag, const char *str)
5138{
5139 const char *p;
7c9d8e07
FB		 5140 char option[128];
5141
5142 p = str;
5143 for(;;) {
609497ab 5144 p = get_opt_name(option, sizeof(option), p);
7c9d8e07
FB		 5145 if (*p != '=')
5146 break;
5147 p++;
5148 if (!strcmp(tag, option)) {
609497ab 5149 (void)get_opt_value(buf, buf_size, p);
e4bcb14c 5150 return strlen(buf);
7c9d8e07 5151 } else {
609497ab 5152 p = get_opt_value(NULL, 0, p);
7c9d8e07
FB		 5153 }
5154 if (*p != ',')
5155 break;
5156 p++;
5157 }
5158 return 0;
5159}
5160
e4bcb14c 5161static int check_params(char *buf, int buf_size,
7ccfb2eb 5162 const char * const *params, const char *str)
e4bcb14c
TS		 5163{
5164 const char *p;
5165 int i;
5166
5167 p = str;
5168 for(;;) {
609497ab 5169 p = get_opt_name(buf, buf_size, p);
e4bcb14c
TS		 5170 if (*p != '=')
5171 return -1;
5172 p++;
5173 for(i = 0; params[i] != NULL; i++)
5174 if (!strcmp(params[i], buf))
5175 break;
5176 if (params[i] == NULL)
5177 return -1;
609497ab 5178 p = get_opt_value(NULL, 0, p);
e4bcb14c
TS		 5179 if (*p != ',')
5180 break;
5181 p++;
5182 }
5183 return 0;
5184}
5185
9ad97e65 5186static int net_client_init(const char *device, const char *p)
7c9d8e07 5187{
7c9d8e07
FB		 5188 char buf[1024];
5189 int vlan_id, ret;
5190 VLANState *vlan;
5191
7c9d8e07
FB		 5192 vlan_id = 0;
5193 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
5194 vlan_id = strtol(buf, NULL, 0);
5195 }
5196 vlan = qemu_find_vlan(vlan_id);
5197 if (!vlan) {
5198 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
5199 return -1;
5200 }
5201 if (!strcmp(device, "nic")) {
5202 NICInfo *nd;
5203 uint8_t *macaddr;
5204
5205 if (nb_nics >= MAX_NICS) {
5206 fprintf(stderr, "Too Many NICs\n");
5207 return -1;
5208 }
5209 nd = &nd_table[nb_nics];
5210 macaddr = nd->macaddr;
5211 macaddr[0] = 0x52;
5212 macaddr[1] = 0x54;
5213 macaddr[2] = 0x00;
5214 macaddr[3] = 0x12;
5215 macaddr[4] = 0x34;
5216 macaddr[5] = 0x56 + nb_nics;
5217
5218 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
5219 if (parse_macaddr(macaddr, buf) < 0) {
5220 fprintf(stderr, "invalid syntax for ethernet address\n");
5221 return -1;
5222 }
5223 }
a41b2ff2
PB		 5224 if (get_param_value(buf, sizeof(buf), "model", p)) {
5225 nd->model = strdup(buf);
5226 }
7c9d8e07
FB		 5227 nd->vlan = vlan;
5228 nb_nics++;
833c7174 5229 vlan->nb_guest_devs++;
7c9d8e07
FB		 5230 ret = 0;
5231 } else
5232 if (!strcmp(device, "none")) {
5233 /* does nothing. It is needed to signal that no network cards
5234 are wanted */
5235 ret = 0;
5236 } else
5237#ifdef CONFIG_SLIRP
5238 if (!strcmp(device, "user")) {
115defd1 5239 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
3f423c9c 5240 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
115defd1 5241 }
833c7174 5242 vlan->nb_host_devs++;
7c9d8e07
FB		 5243 ret = net_slirp_init(vlan);
5244 } else
5245#endif
7fb843f8
FB		 5246#ifdef _WIN32
5247 if (!strcmp(device, "tap")) {
5248 char ifname[64];
5249 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5250 fprintf(stderr, "tap: no interface name\n");
5251 return -1;
5252 }
833c7174 5253 vlan->nb_host_devs++;
7fb843f8
FB		 5254 ret = tap_win32_init(vlan, ifname);
5255 } else
5256#else
7c9d8e07
FB		 5257 if (!strcmp(device, "tap")) {
5258 char ifname[64];
b46a8906 5259 char setup_script[1024], down_script[1024];
7c9d8e07 5260 int fd;
4f01035f 5261 vlan->nb_host_devs++;
7c9d8e07
FB		 5262 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5263 fd = strtol(buf, NULL, 0);
64538cdf 5264 fcntl(fd, F_SETFL, O_NONBLOCK);
7c9d8e07
FB		 5265 ret = -1;
5266 if (net_tap_fd_init(vlan, fd))
5267 ret = 0;
5268 } else {
bf8c5342
FB		 5269 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
5270 ifname[0] = '\0';
5271 }
7c9d8e07
FB		 5272 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
5273 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
5274 }
b46a8906
TS		 5275 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
5276 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
5277 }
5278 ret = net_tap_init(vlan, ifname, setup_script, down_script);
7c9d8e07
FB		 5279 }
5280 } else
fd1dff4b 5281#endif
7c9d8e07
FB		 5282 if (!strcmp(device, "socket")) {
5283 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
5284 int fd;
5285 fd = strtol(buf, NULL, 0);
5286 ret = -1;
5287 if (net_socket_fd_init(vlan, fd, 1))
5288 ret = 0;
5289 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
5290 ret = net_socket_listen_init(vlan, buf);
5291 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
5292 ret = net_socket_connect_init(vlan, buf);
3d830459
FB		 5293 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
5294 ret = net_socket_mcast_init(vlan, buf);
7c9d8e07
FB		 5295 } else {
5296 fprintf(stderr, "Unknown socket options: %s\n", p);
5297 return -1;
5298 }
833c7174 5299 vlan->nb_host_devs++;
7c9d8e07 5300 } else
8a16d273
TS		 5301#ifdef CONFIG_VDE
5302 if (!strcmp(device, "vde")) {
5303 char vde_sock[1024], vde_group[512];
5304 int vde_port, vde_mode;
5305 vlan->nb_host_devs++;
5306 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
5307 vde_sock[0] = '\0';
5308 }
5309 if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
5310 vde_port = strtol(buf, NULL, 10);
5311 } else {
5312 vde_port = 0;
5313 }
5314 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
5315 vde_group[0] = '\0';
5316 }
5317 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
5318 vde_mode = strtol(buf, NULL, 8);
5319 } else {
5320 vde_mode = 0700;
5321 }
5322 ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode);
5323 } else
5324#endif
7c9d8e07
FB		 5325 {
5326 fprintf(stderr, "Unknown network device: %s\n", device);
5327 return -1;
5328 }
5329 if (ret < 0) {
5330 fprintf(stderr, "Could not initialize device '%s'\n", device);
5331 }
3b46e624 5332
7c9d8e07
FB		 5333 return ret;
5334}
5335
9ad97e65
AZ		 5336static int net_client_parse(const char *str)
5337{
5338 const char *p;
5339 char *q;
5340 char device[64];
5341
5342 p = str;
5343 q = device;
5344 while (*p != '\0' && *p != ',') {
5345 if ((q - device) < sizeof(device) - 1)
5346 *q++ = *p;
5347 p++;
5348 }
5349 *q = '\0';
5350 if (*p == ',')
5351 p++;
5352
5353 return net_client_init(device, p);
5354}
5355
7c9d8e07
FB		 5356void do_info_network(void)
5357{
5358 VLANState *vlan;
5359 VLANClientState *vc;
5360
5361 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
5362 term_printf("VLAN %d devices:\n", vlan->id);
5363 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
5364 term_printf(" %s\n", vc->info_str);
5365 }
5366}
42550fde 5367
1ae26a18
AZ		 5368/***********************************************************/
5369/* Bluetooth support */
5370static int nb_hcis;
5371static int cur_hci;
5372static struct HCIInfo *hci_table[MAX_NICS];
5373static struct bt_vlan_s {
5374 struct bt_scatternet_s net;
5375 int id;
5376 struct bt_vlan_s *next;
5377} *first_bt_vlan;
5378
5379/* find or alloc a new bluetooth "VLAN" */
674bb261 5380static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1ae26a18
AZ		 5381{
5382 struct bt_vlan_s **pvlan, *vlan;
5383 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
5384 if (vlan->id == id)
5385 return &vlan->net;
5386 }
5387 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
5388 vlan->id = id;
5389 pvlan = &first_bt_vlan;
5390 while (*pvlan != NULL)
5391 pvlan = &(*pvlan)->next;
5392 *pvlan = vlan;
5393 return &vlan->net;
5394}
5395
5396static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
5397{
5398}
5399
5400static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
5401{
5402 return -ENOTSUP;
5403}
5404
5405static struct HCIInfo null_hci = {
5406 .cmd_send = null_hci_send,
5407 .sco_send = null_hci_send,
5408 .acl_send = null_hci_send,
5409 .bdaddr_set = null_hci_addr_set,
5410};
5411
5412struct HCIInfo *qemu_next_hci(void)
5413{
5414 if (cur_hci == nb_hcis)
5415 return &null_hci;
5416
5417 return hci_table[cur_hci++];
5418}
5419
5420/***********************************************************/
5421/* QEMU Block devices */
5422
609497ab 5423#define HD_ALIAS "index=%d,media=disk"
e4bcb14c
TS		 5424#ifdef TARGET_PPC
5425#define CDROM_ALIAS "index=1,media=cdrom"
5426#else
5427#define CDROM_ALIAS "index=2,media=cdrom"
5428#endif
5429#define FD_ALIAS "index=%d,if=floppy"
609497ab
AZ		 5430#define PFLASH_ALIAS "if=pflash"
5431#define MTD_ALIAS "if=mtd"
9d413d1d 5432#define SD_ALIAS "index=0,if=sd"
e4bcb14c 5433
609497ab 5434static int drive_add(const char *file, const char *fmt, ...)
e4bcb14c
TS		 5435{
5436 va_list ap;
5437
5438 if (nb_drives_opt >= MAX_DRIVES) {
5439 fprintf(stderr, "qemu: too many drives\n");
5440 exit(1);
5441 }
5442
609497ab 5443 drives_opt[nb_drives_opt].file = file;
e4bcb14c 5444 va_start(ap, fmt);
609497ab
AZ		 5445 vsnprintf(drives_opt[nb_drives_opt].opt,
5446 sizeof(drives_opt[0].opt), fmt, ap);
e4bcb14c
TS		 5447 va_end(ap);
5448
5449 return nb_drives_opt++;
5450}
5451
f60d39bc 5452int drive_get_index(BlockInterfaceType type, int bus, int unit)
e4bcb14c
TS		 5453{
5454 int index;
5455
5456 /* seek interface, bus and unit */
5457
5458 for (index = 0; index < nb_drives; index++)
f60d39bc 5459 if (drives_table[index].type == type &&
e4bcb14c
TS		 5460 drives_table[index].bus == bus &&
5461 drives_table[index].unit == unit)
5462 return index;
5463
5464 return -1;
5465}
5466
f60d39bc 5467int drive_get_max_bus(BlockInterfaceType type)
e4bcb14c
TS		 5468{
5469 int max_bus;
5470 int index;
5471
5472 max_bus = -1;
5473 for (index = 0; index < nb_drives; index++) {
f60d39bc 5474 if(drives_table[index].type == type &&
e4bcb14c
TS		 5475 drives_table[index].bus > max_bus)
5476 max_bus = drives_table[index].bus;
5477 }
5478 return max_bus;
5479}
5480
a1620fac
AJ		 5481static void bdrv_format_print(void *opaque, const char *name)
5482{
5483 fprintf(stderr, " %s", name);
5484}
5485
609497ab
AZ		 5486static int drive_init(struct drive_opt *arg, int snapshot,
5487 QEMUMachine *machine)
e4bcb14c
TS		 5488{
5489 char buf[128];
5490 char file[1024];
c8522bdf
AZ		 5491 char devname[128];
5492 const char *mediastr = "";
f60d39bc 5493 BlockInterfaceType type;
e4bcb14c
TS		 5494 enum { MEDIA_DISK, MEDIA_CDROM } media;
5495 int bus_id, unit_id;
5496 int cyls, heads, secs, translation;
5497 BlockDriverState *bdrv;
1e72d3b7 5498 BlockDriver *drv = NULL;
e4bcb14c
TS		 5499 int max_devs;
5500 int index;
33f00271
AZ		 5501 int cache;
5502 int bdrv_flags;
609497ab 5503 char *str = arg->opt;
7ccfb2eb
BS		 5504 static const char * const params[] = { "bus", "unit", "if", "index",
5505 "cyls", "heads", "secs", "trans",
5506 "media", "snapshot", "file",
5507 "cache", "format", NULL };
e4bcb14c
TS		 5508
5509 if (check_params(buf, sizeof(buf), params, str) < 0) {
ff993638 5510 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
e4bcb14c
TS		 5511 buf, str);
5512 return -1;
5513 }
5514
5515 file[0] = 0;
5516 cyls = heads = secs = 0;
5517 bus_id = 0;
5518 unit_id = -1;
5519 translation = BIOS_ATA_TRANSLATION_AUTO;
5520 index = -1;
33f00271 5521 cache = 1;
e4bcb14c 5522
c9b1ae2c 5523 if (machine->use_scsi) {
f60d39bc 5524 type = IF_SCSI;
e4bcb14c 5525 max_devs = MAX_SCSI_DEVS;
363a37d5 5526 pstrcpy(devname, sizeof(devname), "scsi");
e4bcb14c 5527 } else {
f60d39bc 5528 type = IF_IDE;
e4bcb14c 5529 max_devs = MAX_IDE_DEVS;
363a37d5 5530 pstrcpy(devname, sizeof(devname), "ide");
e4bcb14c
TS		 5531 }
5532 media = MEDIA_DISK;
5533
5534 /* extract parameters */
5535
5536 if (get_param_value(buf, sizeof(buf), "bus", str)) {
5537 bus_id = strtol(buf, NULL, 0);
5538 if (bus_id < 0) {
5539 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5540 return -1;
5541 }
5542 }
5543
5544 if (get_param_value(buf, sizeof(buf), "unit", str)) {
5545 unit_id = strtol(buf, NULL, 0);
5546 if (unit_id < 0) {
5547 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5548 return -1;
5549 }
5550 }
5551
5552 if (get_param_value(buf, sizeof(buf), "if", str)) {
ae45d369 5553 pstrcpy(devname, sizeof(devname), buf);
e4bcb14c 5554 if (!strcmp(buf, "ide")) {
f60d39bc 5555 type = IF_IDE;
e4bcb14c
TS		 5556 max_devs = MAX_IDE_DEVS;
5557 } else if (!strcmp(buf, "scsi")) {
f60d39bc 5558 type = IF_SCSI;
e4bcb14c
TS		 5559 max_devs = MAX_SCSI_DEVS;
5560 } else if (!strcmp(buf, "floppy")) {
f60d39bc 5561 type = IF_FLOPPY;
e4bcb14c
TS		 5562 max_devs = 0;
5563 } else if (!strcmp(buf, "pflash")) {
f60d39bc 5564 type = IF_PFLASH;
e4bcb14c
TS		 5565 max_devs = 0;
5566 } else if (!strcmp(buf, "mtd")) {
f60d39bc 5567 type = IF_MTD;
e4bcb14c
TS		 5568 max_devs = 0;
5569 } else if (!strcmp(buf, "sd")) {
f60d39bc 5570 type = IF_SD;
e4bcb14c
TS		 5571 max_devs = 0;
5572 } else {
5573 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5574 return -1;
5575 }
5576 }
5577
5578 if (get_param_value(buf, sizeof(buf), "index", str)) {
5579 index = strtol(buf, NULL, 0);
5580 if (index < 0) {
5581 fprintf(stderr, "qemu: '%s' invalid index\n", str);
5582 return -1;
5583 }
5584 }
5585
5586 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5587 cyls = strtol(buf, NULL, 0);
5588 }
5589
5590 if (get_param_value(buf, sizeof(buf), "heads", str)) {
5591 heads = strtol(buf, NULL, 0);
5592 }
5593
5594 if (get_param_value(buf, sizeof(buf), "secs", str)) {
5595 secs = strtol(buf, NULL, 0);
5596 }
5597
5598 if (cyls || heads || secs) {
5599 if (cyls < 1 || cyls > 16383) {
5600 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5601 return -1;
5602 }
5603 if (heads < 1 || heads > 16) {
5604 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5605 return -1;
5606 }
5607 if (secs < 1 || secs > 63) {
5608 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5609 return -1;
5610 }
5611 }
5612
5613 if (get_param_value(buf, sizeof(buf), "trans", str)) {
5614 if (!cyls) {
5615 fprintf(stderr,
5616 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5617 str);
5618 return -1;
5619 }
5620 if (!strcmp(buf, "none"))
5621 translation = BIOS_ATA_TRANSLATION_NONE;
5622 else if (!strcmp(buf, "lba"))
5623 translation = BIOS_ATA_TRANSLATION_LBA;
5624 else if (!strcmp(buf, "auto"))
5625 translation = BIOS_ATA_TRANSLATION_AUTO;
5626 else {
5627 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5628 return -1;
5629 }
5630 }
5631
5632 if (get_param_value(buf, sizeof(buf), "media", str)) {
5633 if (!strcmp(buf, "disk")) {
5634 media = MEDIA_DISK;
5635 } else if (!strcmp(buf, "cdrom")) {
5636 if (cyls || secs || heads) {
5637 fprintf(stderr,
5638 "qemu: '%s' invalid physical CHS format\n", str);
5639 return -1;
5640 }
5641 media = MEDIA_CDROM;
5642 } else {
5643 fprintf(stderr, "qemu: '%s' invalid media\n", str);
5644 return -1;
5645 }
5646 }
5647
5648 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5649 if (!strcmp(buf, "on"))
5650 snapshot = 1;
5651 else if (!strcmp(buf, "off"))
5652 snapshot = 0;
5653 else {
5654 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5655 return -1;
5656 }
5657 }
5658
33f00271
AZ		 5659 if (get_param_value(buf, sizeof(buf), "cache", str)) {
5660 if (!strcmp(buf, "off"))
5661 cache = 0;
5662 else if (!strcmp(buf, "on"))
5663 cache = 1;
5664 else {
5665 fprintf(stderr, "qemu: invalid cache option\n");
5666 return -1;
5667 }
5668 }
5669
1e72d3b7 5670 if (get_param_value(buf, sizeof(buf), "format", str)) {
a1620fac
AJ		 5671 if (strcmp(buf, "?") == 0) {
5672 fprintf(stderr, "qemu: Supported formats:");
5673 bdrv_iterate_format(bdrv_format_print, NULL);
5674 fprintf(stderr, "\n");
5675 return -1;
5676 }
1e72d3b7
AJ		 5677 drv = bdrv_find_format(buf);
5678 if (!drv) {
5679 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5680 return -1;
5681 }
5682 }
5683
609497ab
AZ		 5684 if (arg->file == NULL)
5685 get_param_value(file, sizeof(file), "file", str);
5686 else
5687 pstrcpy(file, sizeof(file), arg->file);
e4bcb14c
TS		 5688
5689 /* compute bus and unit according index */
5690
5691 if (index != -1) {
5692 if (bus_id != 0 || unit_id != -1) {
5693 fprintf(stderr,
5694 "qemu: '%s' index cannot be used with bus and unit\n", str);
5695 return -1;
5696 }
5697 if (max_devs == 0)
5698 {
5699 unit_id = index;
5700 bus_id = 0;
5701 } else {
5702 unit_id = index % max_devs;
5703 bus_id = index / max_devs;
5704 }
5705 }
5706
5707 /* if user doesn't specify a unit_id,
5708 * try to find the first free
5709 */
5710
5711 if (unit_id == -1) {
5712 unit_id = 0;
f60d39bc 5713 while (drive_get_index(type, bus_id, unit_id) != -1) {
e4bcb14c
TS		 5714 unit_id++;
5715 if (max_devs && unit_id >= max_devs) {
5716 unit_id -= max_devs;
5717 bus_id++;
5718 }
5719 }
5720 }
5721
5722 /* check unit id */
5723
5724 if (max_devs && unit_id >= max_devs) {
5725 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5726 str, unit_id, max_devs - 1);
5727 return -1;
5728 }
5729
5730 /*
5731 * ignore multiple definitions
5732 */
5733
f60d39bc 5734 if (drive_get_index(type, bus_id, unit_id) != -1)
e4bcb14c
TS		 5735 return 0;
5736
5737 /* init */
5738
f60d39bc 5739 if (type == IF_IDE || type == IF_SCSI)
c8522bdf 5740 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
e6198a70
AZ		 5741 if (max_devs)
5742 snprintf(buf, sizeof(buf), "%s%i%s%i",
5743 devname, bus_id, mediastr, unit_id);
5744 else
5745 snprintf(buf, sizeof(buf), "%s%s%i",
5746 devname, mediastr, unit_id);
e4bcb14c
TS		 5747 bdrv = bdrv_new(buf);
5748 drives_table[nb_drives].bdrv = bdrv;
f60d39bc 5749 drives_table[nb_drives].type = type;
e4bcb14c
TS		 5750 drives_table[nb_drives].bus = bus_id;
5751 drives_table[nb_drives].unit = unit_id;
5752 nb_drives++;
5753
f60d39bc 5754 switch(type) {
e4bcb14c
TS		 5755 case IF_IDE:
5756 case IF_SCSI:
5757 switch(media) {
5758 case MEDIA_DISK:
5759 if (cyls != 0) {
5760 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5761 bdrv_set_translation_hint(bdrv, translation);
5762 }
5763 break;
5764 case MEDIA_CDROM:
5765 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5766 break;
5767 }
5768 break;
5769 case IF_SD:
5770 /* FIXME: This isn't really a floppy, but it's a reasonable
5771 approximation. */
5772 case IF_FLOPPY:
5773 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5774 break;
5775 case IF_PFLASH:
5776 case IF_MTD:
5777 break;
5778 }
5779 if (!file[0])
5780 return 0;
33f00271
AZ		 5781 bdrv_flags = 0;
5782 if (snapshot)
5783 bdrv_flags |= BDRV_O_SNAPSHOT;
5784 if (!cache)
5785 bdrv_flags |= BDRV_O_DIRECT;
83ab7950 5786 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
e4bcb14c
TS		 5787 fprintf(stderr, "qemu: could not open disk image %s\n",
5788 file);
5789 return -1;
5790 }
5791 return 0;
5792}
5793
a594cfbf
FB		 5794/***********************************************************/
5795/* USB devices */
5796
0d92ed30
PB		 5797static USBPort *used_usb_ports;
5798static USBPort *free_usb_ports;
5799
5800/* ??? Maybe change this to register a hub to keep track of the topology. */
5801void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5802 usb_attachfn attach)
5803{
5804 port->opaque = opaque;
5805 port->index = index;
5806 port->attach = attach;
5807 port->next = free_usb_ports;
5808 free_usb_ports = port;
5809}
5810
4b096fc9
AL		 5811int usb_device_add_dev(USBDevice *dev)
5812{
5813 USBPort *port;
5814
5815 /* Find a USB port to add the device to. */
5816 port = free_usb_ports;
5817 if (!port->next) {
5818 USBDevice *hub;
5819
5820 /* Create a new hub and chain it on. */
5821 free_usb_ports = NULL;
5822 port->next = used_usb_ports;
5823 used_usb_ports = port;
5824
5825 hub = usb_hub_init(VM_USB_HUB_SIZE);
5826 usb_attach(port, hub);
5827 port = free_usb_ports;
5828 }
5829
5830 free_usb_ports = port->next;
5831 port->next = used_usb_ports;
5832 used_usb_ports = port;
5833 usb_attach(port, dev);
5834 return 0;
5835}
5836
a594cfbf
FB		 5837static int usb_device_add(const char *devname)
5838{
5839 const char *p;
5840 USBDevice *dev;
a594cfbf 5841
0d92ed30 5842 if (!free_usb_ports)
a594cfbf
FB		 5843 return -1;
5844
5845 if (strstart(devname, "host:", &p)) {
5846 dev = usb_host_device_open(p);
a594cfbf
FB		 5847 } else if (!strcmp(devname, "mouse")) {
5848 dev = usb_mouse_init();
09b26c5e 5849 } else if (!strcmp(devname, "tablet")) {
47b2d338
AZ		 5850 dev = usb_tablet_init();
5851 } else if (!strcmp(devname, "keyboard")) {
5852 dev = usb_keyboard_init();
2e5d83bb
PB		 5853 } else if (strstart(devname, "disk:", &p)) {
5854 dev = usb_msd_init(p);
f6d2a316
AZ		 5855 } else if (!strcmp(devname, "wacom-tablet")) {
5856 dev = usb_wacom_init();
a7954218
AZ		 5857 } else if (strstart(devname, "serial:", &p)) {
5858 dev = usb_serial_init(p);
2e4d9fb1
AJ		 5859#ifdef CONFIG_BRLAPI
5860 } else if (!strcmp(devname, "braille")) {
5861 dev = usb_baum_init();
5862#endif
6c9f886c 5863 } else if (strstart(devname, "net:", &p)) {
9ad97e65 5864 int nic = nb_nics;
6c9f886c 5865
9ad97e65 5866 if (net_client_init("nic", p) < 0)
6c9f886c 5867 return -1;
9ad97e65
AZ		 5868 nd_table[nic].model = "usb";
5869 dev = usb_net_init(&nd_table[nic]);
a594cfbf
FB		 5870 } else {
5871 return -1;
5872 }
0d92ed30
PB		 5873 if (!dev)
5874 return -1;
5875
4b096fc9 5876 return usb_device_add_dev(dev);
a594cfbf
FB		 5877}
5878
1f3870ab 5879int usb_device_del_addr(int bus_num, int addr)
a594cfbf 5880{
0d92ed30
PB		 5881 USBPort *port;
5882 USBPort **lastp;
059809e4 5883 USBDevice *dev;
a594cfbf 5884
0d92ed30 5885 if (!used_usb_ports)
a594cfbf
FB		 5886 return -1;
5887
a594cfbf
FB		 5888 if (bus_num != 0)
5889 return -1;
0d92ed30
PB		 5890
5891 lastp = &used_usb_ports;
5892 port = used_usb_ports;
5893 while (port && port->dev->addr != addr) {
5894 lastp = &port->next;
5895 port = port->next;
a594cfbf 5896 }
0d92ed30
PB		 5897
5898 if (!port)
a594cfbf 5899 return -1;
0d92ed30 5900
059809e4 5901 dev = port->dev;
0d92ed30
PB		 5902 *lastp = port->next;
5903 usb_attach(port, NULL);
059809e4 5904 dev->handle_destroy(dev);
0d92ed30
PB		 5905 port->next = free_usb_ports;
5906 free_usb_ports = port;
a594cfbf
FB		 5907 return 0;
5908}
5909
1f3870ab
AL		 5910static int usb_device_del(const char *devname)
5911{
5912 int bus_num, addr;
5913 const char *p;
5914
5d0c5750
AL		 5915 if (strstart(devname, "host:", &p))
5916 return usb_host_device_close(p);
5917
1f3870ab
AL		 5918 if (!used_usb_ports)
5919 return -1;
5920
5921 p = strchr(devname, '.');
5922 if (!p)
5923 return -1;
5924 bus_num = strtoul(devname, NULL, 0);
5925 addr = strtoul(p + 1, NULL, 0);
5926
5927 return usb_device_del_addr(bus_num, addr);
5928}
5929
a594cfbf
FB		 5930void do_usb_add(const char *devname)
5931{
4b096fc9 5932 usb_device_add(devname);
a594cfbf
FB		 5933}
5934
5935void do_usb_del(const char *devname)
5936{
4b096fc9 5937 usb_device_del(devname);
a594cfbf
FB		 5938}
5939
5940void usb_info(void)
5941{
5942 USBDevice *dev;
0d92ed30 5943 USBPort *port;
a594cfbf
FB		 5944 const char *speed_str;
5945
0d92ed30 5946 if (!usb_enabled) {
a594cfbf
FB		 5947 term_printf("USB support not enabled\n");
5948 return;
5949 }
5950
0d92ed30
PB		 5951 for (port = used_usb_ports; port; port = port->next) {
5952 dev = port->dev;
5953 if (!dev)
5954 continue;
5955 switch(dev->speed) {
5fafdf24
TS		 5956 case USB_SPEED_LOW:
5957 speed_str = "1.5";
0d92ed30 5958 break;
5fafdf24
TS		 5959 case USB_SPEED_FULL:
5960 speed_str = "12";
0d92ed30 5961 break;
5fafdf24
TS		 5962 case USB_SPEED_HIGH:
5963 speed_str = "480";
0d92ed30
PB		 5964 break;
5965 default:
5fafdf24 5966 speed_str = "?";
0d92ed30 5967 break;
a594cfbf 5968 }
5fafdf24 5969 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
1f6e24e7 5970 0, dev->addr, speed_str, dev->devname);
a594cfbf
FB		 5971 }
5972}
5973
201a51fc
AZ		 5974/***********************************************************/
5975/* PCMCIA/Cardbus */
5976
5977static struct pcmcia_socket_entry_s {
5978 struct pcmcia_socket_s *socket;
5979 struct pcmcia_socket_entry_s *next;
5980} *pcmcia_sockets = 0;
5981
5982void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5983{
5984 struct pcmcia_socket_entry_s *entry;
5985
5986 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5987 entry->socket = socket;
5988 entry->next = pcmcia_sockets;
5989 pcmcia_sockets = entry;
5990}
5991
5992void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5993{
5994 struct pcmcia_socket_entry_s *entry, **ptr;
5995
5996 ptr = &pcmcia_sockets;
5997 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5998 if (entry->socket == socket) {
5999 *ptr = entry->next;
6000 qemu_free(entry);
6001 }
6002}
6003
6004void pcmcia_info(void)
6005{
6006 struct pcmcia_socket_entry_s *iter;
6007 if (!pcmcia_sockets)
6008 term_printf("No PCMCIA sockets\n");
6009
6010 for (iter = pcmcia_sockets; iter; iter = iter->next)
6011 term_printf("%s: %s\n", iter->socket->slot_string,
6012 iter->socket->attached ? iter->socket->card_string :
6013 "Empty");
6014}
6015
2ff89790
TS		 6016/***********************************************************/
6017/* dumb display */
6018
6019static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
6020{
6021}
6022
6023static void dumb_resize(DisplayState *ds, int w, int h)
6024{
6025}
6026
6027static void dumb_refresh(DisplayState *ds)
6028{
6029#if defined(CONFIG_SDL)
6030 vga_hw_update();
6031#endif
6032}
6033
6034static void dumb_display_init(DisplayState *ds)
6035{
6036 ds->data = NULL;
6037 ds->linesize = 0;
6038 ds->depth = 0;
6039 ds->dpy_update = dumb_update;
6040 ds->dpy_resize = dumb_resize;
6041 ds->dpy_refresh = dumb_refresh;
bcfad70f
AL		 6042 ds->gui_timer_interval = 500;
6043 ds->idle = 1;
2ff89790
TS		 6044}
6045
8a7ddc38
FB		 6046/***********************************************************/
6047/* I/O handling */
0824d6fc 6048
c4b1fcc0
FB		 6049#define MAX_IO_HANDLERS 64
6050
6051typedef struct IOHandlerRecord {
6052 int fd;
7c9d8e07
FB		 6053 IOCanRWHandler *fd_read_poll;
6054 IOHandler *fd_read;
6055 IOHandler *fd_write;
cafffd40 6056 int deleted;
c4b1fcc0
FB		 6057 void *opaque;
6058 /* temporary data */
6059 struct pollfd *ufd;
8a7ddc38 6060 struct IOHandlerRecord *next;
c4b1fcc0
FB		 6061} IOHandlerRecord;
6062
8a7ddc38 6063static IOHandlerRecord *first_io_handler;
c4b1fcc0 6064
7c9d8e07
FB		 6065/* XXX: fd_read_poll should be suppressed, but an API change is
6066 necessary in the character devices to suppress fd_can_read(). */
5fafdf24
TS		 6067int qemu_set_fd_handler2(int fd,
6068 IOCanRWHandler *fd_read_poll,
6069 IOHandler *fd_read,
6070 IOHandler *fd_write,
7c9d8e07 6071 void *opaque)
c4b1fcc0 6072{
7c9d8e07 6073 IOHandlerRecord **pioh, *ioh;
c4b1fcc0 6074
7c9d8e07
FB		 6075 if (!fd_read && !fd_write) {
6076 pioh = &first_io_handler;
6077 for(;;) {
6078 ioh = *pioh;
6079 if (ioh == NULL)
6080 break;
6081 if (ioh->fd == fd) {
cafffd40 6082 ioh->deleted = 1;
7c9d8e07
FB		 6083 break;
6084 }
6085 pioh = &ioh->next;
6086 }
6087 } else {
6088 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6089 if (ioh->fd == fd)
6090 goto found;
6091 }
6092 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
6093 if (!ioh)
6094 return -1;
6095 ioh->next = first_io_handler;
6096 first_io_handler = ioh;
6097 found:
6098 ioh->fd = fd;
6099 ioh->fd_read_poll = fd_read_poll;
6100 ioh->fd_read = fd_read;
6101 ioh->fd_write = fd_write;
6102 ioh->opaque = opaque;
cafffd40 6103 ioh->deleted = 0;
7c9d8e07 6104 }
c4b1fcc0
FB		 6105 return 0;
6106}
6107
5fafdf24
TS		 6108int qemu_set_fd_handler(int fd,
6109 IOHandler *fd_read,
6110 IOHandler *fd_write,
7c9d8e07 6111 void *opaque)
8a7ddc38 6112{
7c9d8e07 6113 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
8a7ddc38
FB		 6114}
6115
f331110f
FB		 6116/***********************************************************/
6117/* Polling handling */
6118
6119typedef struct PollingEntry {
6120 PollingFunc *func;
6121 void *opaque;
6122 struct PollingEntry *next;
6123} PollingEntry;
6124
6125static PollingEntry *first_polling_entry;
6126
6127int qemu_add_polling_cb(PollingFunc *func, void *opaque)
6128{
6129 PollingEntry **ppe, *pe;
6130 pe = qemu_mallocz(sizeof(PollingEntry));
6131 if (!pe)
6132 return -1;
6133 pe->func = func;
6134 pe->opaque = opaque;
6135 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
6136 *ppe = pe;
6137 return 0;
6138}
6139
6140void qemu_del_polling_cb(PollingFunc *func, void *opaque)
6141{
6142 PollingEntry **ppe, *pe;
6143 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
6144 pe = *ppe;
6145 if (pe->func == func && pe->opaque == opaque) {
6146 *ppe = pe->next;
6147 qemu_free(pe);
6148 break;
6149 }
6150 }
6151}
6152
a18e524a
FB		 6153#ifdef _WIN32
6154/***********************************************************/
6155/* Wait objects support */
6156typedef struct WaitObjects {
6157 int num;
6158 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
6159 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
6160 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
6161} WaitObjects;
6162
6163static WaitObjects wait_objects = {0};
3b46e624 6164
a18e524a
FB		 6165int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6166{
6167 WaitObjects *w = &wait_objects;
6168
6169 if (w->num >= MAXIMUM_WAIT_OBJECTS)
6170 return -1;
6171 w->events[w->num] = handle;
6172 w->func[w->num] = func;
6173 w->opaque[w->num] = opaque;
6174 w->num++;
6175 return 0;
6176}
6177
6178void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
6179{
6180 int i, found;
6181 WaitObjects *w = &wait_objects;
6182
6183 found = 0;
6184 for (i = 0; i < w->num; i++) {
6185 if (w->events[i] == handle)
6186 found = 1;
6187 if (found) {
6188 w->events[i] = w->events[i + 1];
6189 w->func[i] = w->func[i + 1];
6190 w->opaque[i] = w->opaque[i + 1];
3b46e624 6191 }
a18e524a
FB		 6192 }
6193 if (found)
6194 w->num--;
6195}
6196#endif
6197
8a7ddc38
FB		 6198/***********************************************************/
6199/* savevm/loadvm support */
6200
faea38e7
FB		 6201#define IO_BUF_SIZE 32768
6202
6203struct QEMUFile {
5dafc53f
AL		 6204 QEMUFilePutBufferFunc *put_buffer;
6205 QEMUFileGetBufferFunc *get_buffer;
6206 QEMUFileCloseFunc *close;
6207 QEMUFileRateLimit *rate_limit;
6208 void *opaque;
6209
faea38e7
FB		 6210 int64_t buf_offset; /* start of buffer when writing, end of buffer
6211 when reading */
6212 int buf_index;
6213 int buf_size; /* 0 when writing */
6214 uint8_t buf[IO_BUF_SIZE];
6215};
6216
5dafc53f
AL		 6217typedef struct QEMUFileFD
6218{
6219 int fd;
6220 QEMUFile *file;
6221} QEMUFileFD;
6222
6223static void fd_put_notify(void *opaque)
6224{
6225 QEMUFileFD *s = opaque;
6226
6227 /* Remove writable callback and do a put notify */
6228 qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
6229 qemu_file_put_notify(s->file);
6230}
6231
342b51d7
BS		 6232static void fd_put_buffer(void *opaque, const uint8_t *buf,
6233 int64_t pos, int size)
5dafc53f
AL		 6234{
6235 QEMUFileFD *s = opaque;
6236 ssize_t len;
6237
6238 do {
6239 len = write(s->fd, buf, size);
6240 } while (len == -1 && errno == EINTR);
6241
6242 if (len == -1)
6243 len = -errno;
6244
6245 /* When the fd becomes writable again, register a callback to do
6246 * a put notify */
6247 if (len == -EAGAIN)
6248 qemu_set_fd_handler2(s->fd, NULL, NULL, fd_put_notify, s);
5dafc53f
AL		 6249}
6250
6251static int fd_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6252{
6253 QEMUFileFD *s = opaque;
6254 ssize_t len;
6255
6256 do {
6257 len = read(s->fd, buf, size);
6258 } while (len == -1 && errno == EINTR);
6259
6260 if (len == -1)
6261 len = -errno;
6262
6263 return len;
6264}
6265
6266static int fd_close(void *opaque)
6267{
6268 QEMUFileFD *s = opaque;
6269 qemu_free(s);
6270 return 0;
6271}
6272
6273QEMUFile *qemu_fopen_fd(int fd)
6274{
6275 QEMUFileFD *s = qemu_mallocz(sizeof(QEMUFileFD));
6276
6277 if (s == NULL)
6278 return NULL;
6279
6280 s->fd = fd;
6281 s->file = qemu_fopen_ops(s, fd_put_buffer, fd_get_buffer, fd_close, NULL);
6282 return s->file;
6283}
6284
6285typedef struct QEMUFileStdio
6286{
6287 FILE *outfile;
6288} QEMUFileStdio;
6289
6290static void file_put_buffer(void *opaque, const uint8_t *buf,
6291 int64_t pos, int size)
6292{
6293 QEMUFileStdio *s = opaque;
6294 fseek(s->outfile, pos, SEEK_SET);
6295 fwrite(buf, 1, size, s->outfile);
6296}
6297
6298static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6299{
6300 QEMUFileStdio *s = opaque;
6301 fseek(s->outfile, pos, SEEK_SET);
6302 return fread(buf, 1, size, s->outfile);
6303}
6304
6305static int file_close(void *opaque)
6306{
6307 QEMUFileStdio *s = opaque;
6308 fclose(s->outfile);
6309 qemu_free(s);
6310 return 0;
6311}
6312
faea38e7
FB		 6313QEMUFile *qemu_fopen(const char *filename, const char *mode)
6314{
5dafc53f 6315 QEMUFileStdio *s;
faea38e7 6316
5dafc53f
AL		 6317 s = qemu_mallocz(sizeof(QEMUFileStdio));
6318 if (!s)
faea38e7 6319 return NULL;
5dafc53f
AL		 6320
6321 s->outfile = fopen(filename, mode);
6322 if (!s->outfile)
faea38e7 6323 goto fail;
5dafc53f
AL		 6324
6325 if (!strcmp(mode, "wb"))
6326 return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
6327 else if (!strcmp(mode, "rb"))
6328 return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
6329
6330fail:
6331 if (s->outfile)
6332 fclose(s->outfile);
6333 qemu_free(s);
faea38e7
FB		 6334 return NULL;
6335}
6336
5dafc53f
AL		 6337typedef struct QEMUFileBdrv
6338{
6339 BlockDriverState *bs;
6340 int64_t base_offset;
6341} QEMUFileBdrv;
6342
6343static void bdrv_put_buffer(void *opaque, const uint8_t *buf,
6344 int64_t pos, int size)
6345{
6346 QEMUFileBdrv *s = opaque;
6347 bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
6348}
6349
6350static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6351{
6352 QEMUFileBdrv *s = opaque;
6353 return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
6354}
6355
6356static int bdrv_fclose(void *opaque)
6357{
6358 QEMUFileBdrv *s = opaque;
6359 qemu_free(s);
6360 return 0;
6361}
6362
674bb261 6363static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5dafc53f
AL		 6364{
6365 QEMUFileBdrv *s;
6366
6367 s = qemu_mallocz(sizeof(QEMUFileBdrv));
6368 if (!s)
6369 return NULL;
6370
6371 s->bs = bs;
6372 s->base_offset = offset;
6373
6374 if (is_writable)
6375 return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
6376
6377 return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
6378}
6379
6380QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
6381 QEMUFileGetBufferFunc *get_buffer,
6382 QEMUFileCloseFunc *close,
6383 QEMUFileRateLimit *rate_limit)
faea38e7
FB		 6384{
6385 QEMUFile *f;
6386
6387 f = qemu_mallocz(sizeof(QEMUFile));
6388 if (!f)
6389 return NULL;
5dafc53f
AL		 6390
6391 f->opaque = opaque;
6392 f->put_buffer = put_buffer;
6393 f->get_buffer = get_buffer;
6394 f->close = close;
6395 f->rate_limit = rate_limit;
6396
faea38e7
FB		 6397 return f;
6398}
6399
6400void qemu_fflush(QEMUFile *f)
6401{
5dafc53f 6402 if (!f->put_buffer)
faea38e7 6403 return;
5dafc53f 6404
faea38e7 6405 if (f->buf_index > 0) {
5dafc53f 6406 f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
faea38e7
FB		 6407 f->buf_offset += f->buf_index;
6408 f->buf_index = 0;
6409 }
6410}
6411
6412static void qemu_fill_buffer(QEMUFile *f)
6413{
6414 int len;
6415
5dafc53f 6416 if (!f->get_buffer)
faea38e7 6417 return;
5dafc53f
AL		 6418
6419 len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
6420 if (len < 0)
6421 len = 0;
6422
faea38e7
FB		 6423 f->buf_index = 0;
6424 f->buf_size = len;
6425 f->buf_offset += len;
6426}
6427
5dafc53f 6428int qemu_fclose(QEMUFile *f)
faea38e7 6429{
5dafc53f
AL		 6430 int ret = 0;
6431 qemu_fflush(f);
6432 if (f->close)
6433 ret = f->close(f->opaque);
faea38e7 6434 qemu_free(f);
5dafc53f
AL		 6435 return ret;
6436}
6437
6438void qemu_file_put_notify(QEMUFile *f)
6439{
6440 f->put_buffer(f->opaque, NULL, 0, 0);
faea38e7
FB		 6441}
6442
2ca83a8d 6443void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
b4608c04 6444{
2ca83a8d 6445 int l;
faea38e7
FB		 6446 while (size > 0) {
6447 l = IO_BUF_SIZE - f->buf_index;
6448 if (l > size)
6449 l = size;
6450 memcpy(f->buf + f->buf_index, buf, l);
6451 f->buf_index += l;
6452 buf += l;
6453 size -= l;
6454 if (f->buf_index >= IO_BUF_SIZE)
6455 qemu_fflush(f);
6456 }
b4608c04
FB		 6457}
6458
2ca83a8d 6459void qemu_put_byte(QEMUFile *f, int v)
b4608c04 6460{
faea38e7
FB		 6461 f->buf[f->buf_index++] = v;
6462 if (f->buf_index >= IO_BUF_SIZE)
6463 qemu_fflush(f);
6464}
6465
2ca83a8d 6466int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
faea38e7 6467{
2ca83a8d 6468 int size, l;
faea38e7
FB		 6469
6470 size = size1;
6471 while (size > 0) {
6472 l = f->buf_size - f->buf_index;
6473 if (l == 0) {
6474 qemu_fill_buffer(f);
6475 l = f->buf_size - f->buf_index;
6476 if (l == 0)
6477 break;
6478 }
6479 if (l > size)
6480 l = size;
6481 memcpy(buf, f->buf + f->buf_index, l);
6482 f->buf_index += l;
6483 buf += l;
6484 size -= l;
6485 }
6486 return size1 - size;
6487}
6488
2ca83a8d 6489int qemu_get_byte(QEMUFile *f)
faea38e7
FB		 6490{
6491 if (f->buf_index >= f->buf_size) {
6492 qemu_fill_buffer(f);
6493 if (f->buf_index >= f->buf_size)
6494 return 0;
6495 }
6496 return f->buf[f->buf_index++];
6497}
6498
6499int64_t qemu_ftell(QEMUFile *f)
6500{
6501 return f->buf_offset - f->buf_size + f->buf_index;
6502}
6503
6504int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
6505{
6506 if (whence == SEEK_SET) {
6507 /* nothing to do */
6508 } else if (whence == SEEK_CUR) {
6509 pos += qemu_ftell(f);
6510 } else {
6511 /* SEEK_END not supported */
6512 return -1;
6513 }
5dafc53f 6514 if (f->put_buffer) {
faea38e7
FB		 6515 qemu_fflush(f);
6516 f->buf_offset = pos;
6517 } else {
6518 f->buf_offset = pos;
6519 f->buf_index = 0;
6520 f->buf_size = 0;
6521 }
6522 return pos;
8a7ddc38
FB		 6523}
6524
5dafc53f
AL		 6525int qemu_file_rate_limit(QEMUFile *f)
6526{
6527 if (f->rate_limit)
6528 return f->rate_limit(f->opaque);
6529
6530 return 0;
6531}
6532
2ca83a8d 6533void qemu_put_be16(QEMUFile *f, unsigned int v)
8a7ddc38
FB		 6534{
6535 qemu_put_byte(f, v >> 8);
6536 qemu_put_byte(f, v);
6537}
6538
2ca83a8d 6539void qemu_put_be32(QEMUFile *f, unsigned int v)
8a7ddc38
FB		 6540{
6541 qemu_put_byte(f, v >> 24);
6542 qemu_put_byte(f, v >> 16);
6543 qemu_put_byte(f, v >> 8);
6544 qemu_put_byte(f, v);
6545}
6546
6547void qemu_put_be64(QEMUFile *f, uint64_t v)
6548{
6549 qemu_put_be32(f, v >> 32);
6550 qemu_put_be32(f, v);
6551}
6552
2ca83a8d 6553unsigned int qemu_get_be16(QEMUFile *f)
8a7ddc38 6554{
2ca83a8d 6555 unsigned int v;
8a7ddc38
FB		 6556 v = qemu_get_byte(f) << 8;
6557 v |= qemu_get_byte(f);
6558 return v;
6559}
6560
2ca83a8d 6561unsigned int qemu_get_be32(QEMUFile *f)
8a7ddc38 6562{
2ca83a8d 6563 unsigned int v;
8a7ddc38
FB		 6564 v = qemu_get_byte(f) << 24;
6565 v |= qemu_get_byte(f) << 16;
6566 v |= qemu_get_byte(f) << 8;
6567 v |= qemu_get_byte(f);
6568 return v;
6569}
6570
6571uint64_t qemu_get_be64(QEMUFile *f)
6572{
6573 uint64_t v;
6574 v = (uint64_t)qemu_get_be32(f) << 32;
6575 v |= qemu_get_be32(f);
6576 return v;
6577}
6578
8a7ddc38
FB		 6579typedef struct SaveStateEntry {
6580 char idstr[256];
6581 int instance_id;
6582 int version_id;
6583 SaveStateHandler *save_state;
6584 LoadStateHandler *load_state;
6585 void *opaque;
6586 struct SaveStateEntry *next;
6587} SaveStateEntry;
b4608c04 6588
8a7ddc38
FB		 6589static SaveStateEntry *first_se;
6590
18be5187 6591/* TODO: Individual devices generally have very little idea about the rest
18fdb1c5
TS		 6592 of the system, so instance_id should be removed/replaced.
6593 Meanwhile pass -1 as instance_id if you do not already have a clearly
6594 distinguishing id for all instances of your device class. */
5fafdf24
TS		 6595int register_savevm(const char *idstr,
6596 int instance_id,
8a7ddc38
FB		 6597 int version_id,
6598 SaveStateHandler *save_state,
6599 LoadStateHandler *load_state,
6600 void *opaque)
6601{
6602 SaveStateEntry *se, **pse;
6603
6604 se = qemu_malloc(sizeof(SaveStateEntry));
6605 if (!se)
6606 return -1;
6607 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
18be5187 6608 se->instance_id = (instance_id == -1) ? 0 : instance_id;
8a7ddc38
FB		 6609 se->version_id = version_id;
6610 se->save_state = save_state;
6611 se->load_state = load_state;
6612 se->opaque = opaque;
6613 se->next = NULL;
6614
6615 /* add at the end of list */
6616 pse = &first_se;
18be5187
PB		 6617 while (*pse != NULL) {
6618 if (instance_id == -1
6619 && strcmp(se->idstr, (*pse)->idstr) == 0
6620 && se->instance_id <= (*pse)->instance_id)
6621 se->instance_id = (*pse)->instance_id + 1;
8a7ddc38 6622 pse = &(*pse)->next;
18be5187 6623 }
8a7ddc38
FB		 6624 *pse = se;
6625 return 0;
6626}
6627
6628#define QEMU_VM_FILE_MAGIC 0x5145564d
faea38e7 6629#define QEMU_VM_FILE_VERSION 0x00000002
8a7ddc38 6630
9596ebb7 6631static int qemu_savevm_state(QEMUFile *f)
8a7ddc38
FB		 6632{
6633 SaveStateEntry *se;
faea38e7
FB		 6634 int len, ret;
6635 int64_t cur_pos, len_pos, total_len_pos;
313aa567 6636
8a7ddc38
FB		 6637 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
6638 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
faea38e7
FB		 6639 total_len_pos = qemu_ftell(f);
6640 qemu_put_be64(f, 0); /* total size */
8a7ddc38
FB		 6641
6642 for(se = first_se; se != NULL; se = se->next) {
d978c02c
AJ		 6643 if (se->save_state == NULL)
6644 /* this one has a loader only, for backwards compatibility */
6645 continue;
6646
8a7ddc38
FB		 6647 /* ID string */
6648 len = strlen(se->idstr);
6649 qemu_put_byte(f, len);
ffe8ab83 6650 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
8a7ddc38
FB		 6651
6652 qemu_put_be32(f, se->instance_id);
6653 qemu_put_be32(f, se->version_id);
6654
6655 /* record size: filled later */
faea38e7 6656 len_pos = qemu_ftell(f);
8a7ddc38 6657 qemu_put_be32(f, 0);
8a7ddc38
FB		 6658 se->save_state(f, se->opaque);
6659
6660 /* fill record size */
faea38e7
FB		 6661 cur_pos = qemu_ftell(f);
6662 len = cur_pos - len_pos - 4;
6663 qemu_fseek(f, len_pos, SEEK_SET);
8a7ddc38 6664 qemu_put_be32(f, len);
faea38e7 6665 qemu_fseek(f, cur_pos, SEEK_SET);
8a7ddc38 6666 }
faea38e7
FB		 6667 cur_pos = qemu_ftell(f);
6668 qemu_fseek(f, total_len_pos, SEEK_SET);
6669 qemu_put_be64(f, cur_pos - total_len_pos - 8);
6670 qemu_fseek(f, cur_pos, SEEK_SET);
8a7ddc38 6671
8a7ddc38 6672 ret = 0;
8a7ddc38
FB		 6673 return ret;
6674}
6675
6676static SaveStateEntry *find_se(const char *idstr, int instance_id)
6677{
6678 SaveStateEntry *se;
6679
6680 for(se = first_se; se != NULL; se = se->next) {
5fafdf24 6681 if (!strcmp(se->idstr, idstr) &&
8a7ddc38
FB		 6682 instance_id == se->instance_id)
6683 return se;
6684 }
6685 return NULL;
6686}
6687
9596ebb7 6688static int qemu_loadvm_state(QEMUFile *f)
8a7ddc38
FB		 6689{
6690 SaveStateEntry *se;
faea38e7
FB		 6691 int len, ret, instance_id, record_len, version_id;
6692 int64_t total_len, end_pos, cur_pos;
8a7ddc38
FB		 6693 unsigned int v;
6694 char idstr[256];
3b46e624 6695
8a7ddc38
FB		 6696 v = qemu_get_be32(f);
6697 if (v != QEMU_VM_FILE_MAGIC)
6698 goto fail;
6699 v = qemu_get_be32(f);
6700 if (v != QEMU_VM_FILE_VERSION) {
6701 fail:
8a7ddc38
FB		 6702 ret = -1;
6703 goto the_end;
6704 }
faea38e7
FB		 6705 total_len = qemu_get_be64(f);
6706 end_pos = total_len + qemu_ftell(f);
b4608c04 6707 for(;;) {
faea38e7 6708 if (qemu_ftell(f) >= end_pos)
cd4c3e88 6709 break;
faea38e7 6710 len = qemu_get_byte(f);
ffe8ab83 6711 qemu_get_buffer(f, (uint8_t *)idstr, len);
8a7ddc38
FB		 6712 idstr[len] = '\0';
6713 instance_id = qemu_get_be32(f);
6714 version_id = qemu_get_be32(f);
6715 record_len = qemu_get_be32(f);
6716#if 0
5fafdf24 6717 printf("idstr=%s instance=0x%x version=%d len=%d\n",
8a7ddc38
FB		 6718 idstr, instance_id, version_id, record_len);
6719#endif
faea38e7 6720 cur_pos = qemu_ftell(f);
8a7ddc38
FB		 6721 se = find_se(idstr, instance_id);
6722 if (!se) {
5fafdf24 6723 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
8a7ddc38
FB		 6724 instance_id, idstr);
6725 } else {
6726 ret = se->load_state(f, se->opaque, version_id);
6727 if (ret < 0) {
5fafdf24 6728 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
8a7ddc38
FB		 6729 instance_id, idstr);
6730 }
34865134 6731 }
8a7ddc38
FB		 6732 /* always seek to exact end of record */
6733 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6734 }
8a7ddc38 6735 ret = 0;
faea38e7
FB		 6736 the_end:
6737 return ret;
6738}
6739
6740/* device can contain snapshots */
6741static int bdrv_can_snapshot(BlockDriverState *bs)
6742{
6743 return (bs &&
6744 !bdrv_is_removable(bs) &&
6745 !bdrv_is_read_only(bs));
6746}
6747
6748/* device must be snapshots in order to have a reliable snapshot */
6749static int bdrv_has_snapshot(BlockDriverState *bs)
6750{
6751 return (bs &&
6752 !bdrv_is_removable(bs) &&
6753 !bdrv_is_read_only(bs));
6754}
6755
6756static BlockDriverState *get_bs_snapshots(void)
6757{
6758 BlockDriverState *bs;
6759 int i;
6760
6761 if (bs_snapshots)
6762 return bs_snapshots;
e4bcb14c
TS		 6763 for(i = 0; i <= nb_drives; i++) {
6764 bs = drives_table[i].bdrv;
faea38e7
FB		 6765 if (bdrv_can_snapshot(bs))
6766 goto ok;
6767 }
6768 return NULL;
6769 ok:
6770 bs_snapshots = bs;
6771 return bs;
6772}
6773
6774static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6775 const char *name)
6776{
6777 QEMUSnapshotInfo *sn_tab, *sn;
6778 int nb_sns, i, ret;
3b46e624 6779
faea38e7
FB		 6780 ret = -ENOENT;
6781 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6782 if (nb_sns < 0)
6783 return ret;
6784 for(i = 0; i < nb_sns; i++) {
6785 sn = &sn_tab[i];
6786 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6787 *sn_info = *sn;
6788 ret = 0;
6789 break;
6790 }
6791 }
6792 qemu_free(sn_tab);
6793 return ret;
6794}
6795
6796void do_savevm(const char *name)
6797{
6798 BlockDriverState *bs, *bs1;
6799 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6800 int must_delete, ret, i;
6801 BlockDriverInfo bdi1, *bdi = &bdi1;
6802 QEMUFile *f;
6803 int saved_vm_running;
4c279bdf
FB		 6804#ifdef _WIN32
6805 struct _timeb tb;
6806#else
faea38e7 6807 struct timeval tv;
4c279bdf 6808#endif
faea38e7
FB		 6809
6810 bs = get_bs_snapshots();
6811 if (!bs) {
6812 term_printf("No block device can accept snapshots\n");
6813 return;
6814 }
6815
6192bc37
PB		 6816 /* ??? Should this occur after vm_stop? */
6817 qemu_aio_flush();
6818
faea38e7
FB		 6819 saved_vm_running = vm_running;
6820 vm_stop(0);
3b46e624 6821
faea38e7
FB		 6822 must_delete = 0;
6823 if (name) {
6824 ret = bdrv_snapshot_find(bs, old_sn, name);
6825 if (ret >= 0) {
6826 must_delete = 1;
6827 }
6828 }
6829 memset(sn, 0, sizeof(*sn));
6830 if (must_delete) {
6831 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6832 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6833 } else {
6834 if (name)
6835 pstrcpy(sn->name, sizeof(sn->name), name);
6836 }
6837
6838 /* fill auxiliary fields */
4c279bdf
FB		 6839#ifdef _WIN32
6840 _ftime(&tb);
6841 sn->date_sec = tb.time;
6842 sn->date_nsec = tb.millitm * 1000000;
6843#else
faea38e7
FB		 6844 gettimeofday(&tv, NULL);
6845 sn->date_sec = tv.tv_sec;
6846 sn->date_nsec = tv.tv_usec * 1000;
4c279bdf 6847#endif
faea38e7 6848 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
3b46e624 6849
faea38e7
FB		 6850 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6851 term_printf("Device %s does not support VM state snapshots\n",
6852 bdrv_get_device_name(bs));
6853 goto the_end;
6854 }
3b46e624 6855
faea38e7
FB		 6856 /* save the VM state */
6857 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6858 if (!f) {
6859 term_printf("Could not open VM state file\n");
6860 goto the_end;
6861 }
6862 ret = qemu_savevm_state(f);
6863 sn->vm_state_size = qemu_ftell(f);
6864 qemu_fclose(f);
6865 if (ret < 0) {
6866 term_printf("Error %d while writing VM\n", ret);
6867 goto the_end;
6868 }
3b46e624 6869
faea38e7
FB		 6870 /* create the snapshots */
6871
e4bcb14c
TS		 6872 for(i = 0; i < nb_drives; i++) {
6873 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6874 if (bdrv_has_snapshot(bs1)) {
6875 if (must_delete) {
6876 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6877 if (ret < 0) {
6878 term_printf("Error while deleting snapshot on '%s'\n",
6879 bdrv_get_device_name(bs1));
6880 }
6881 }
6882 ret = bdrv_snapshot_create(bs1, sn);
6883 if (ret < 0) {
6884 term_printf("Error while creating snapshot on '%s'\n",
6885 bdrv_get_device_name(bs1));
6886 }
6887 }
6888 }
6889
8a7ddc38
FB		 6890 the_end:
6891 if (saved_vm_running)
6892 vm_start();
faea38e7
FB		 6893}
6894
6895void do_loadvm(const char *name)
6896{
6897 BlockDriverState *bs, *bs1;
6898 BlockDriverInfo bdi1, *bdi = &bdi1;
6899 QEMUFile *f;
6900 int i, ret;
6901 int saved_vm_running;
6902
6903 bs = get_bs_snapshots();
6904 if (!bs) {
6905 term_printf("No block device supports snapshots\n");
6906 return;
6907 }
3b46e624 6908
6192bc37
PB		 6909 /* Flush all IO requests so they don't interfere with the new state. */
6910 qemu_aio_flush();
6911
faea38e7
FB		 6912 saved_vm_running = vm_running;
6913 vm_stop(0);
6914
e4bcb14c
TS		 6915 for(i = 0; i <= nb_drives; i++) {
6916 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6917 if (bdrv_has_snapshot(bs1)) {
6918 ret = bdrv_snapshot_goto(bs1, name);
6919 if (ret < 0) {
6920 if (bs != bs1)
6921 term_printf("Warning: ");
6922 switch(ret) {
6923 case -ENOTSUP:
6924 term_printf("Snapshots not supported on device '%s'\n",
6925 bdrv_get_device_name(bs1));
6926 break;
6927 case -ENOENT:
6928 term_printf("Could not find snapshot '%s' on device '%s'\n",
6929 name, bdrv_get_device_name(bs1));
6930 break;
6931 default:
6932 term_printf("Error %d while activating snapshot on '%s'\n",
6933 ret, bdrv_get_device_name(bs1));
6934 break;
6935 }
6936 /* fatal on snapshot block device */
6937 if (bs == bs1)
6938 goto the_end;
6939 }
6940 }
6941 }
6942
6943 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6944 term_printf("Device %s does not support VM state snapshots\n",
6945 bdrv_get_device_name(bs));
6946 return;
6947 }
3b46e624 6948
faea38e7
FB		 6949 /* restore the VM state */
6950 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6951 if (!f) {
6952 term_printf("Could not open VM state file\n");
6953 goto the_end;
6954 }
6955 ret = qemu_loadvm_state(f);
6956 qemu_fclose(f);
6957 if (ret < 0) {
6958 term_printf("Error %d while loading VM state\n", ret);
6959 }
6960 the_end:
6961 if (saved_vm_running)
6962 vm_start();
6963}
6964
6965void do_delvm(const char *name)
6966{
6967 BlockDriverState *bs, *bs1;
6968 int i, ret;
6969
6970 bs = get_bs_snapshots();
6971 if (!bs) {
6972 term_printf("No block device supports snapshots\n");
6973 return;
6974 }
3b46e624 6975
e4bcb14c
TS		 6976 for(i = 0; i <= nb_drives; i++) {
6977 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6978 if (bdrv_has_snapshot(bs1)) {
6979 ret = bdrv_snapshot_delete(bs1, name);
6980 if (ret < 0) {
6981 if (ret == -ENOTSUP)
6982 term_printf("Snapshots not supported on device '%s'\n",
6983 bdrv_get_device_name(bs1));
6984 else
6985 term_printf("Error %d while deleting snapshot on '%s'\n",
6986 ret, bdrv_get_device_name(bs1));
6987 }
6988 }
6989 }
6990}
6991
6992void do_info_snapshots(void)
6993{
6994 BlockDriverState *bs, *bs1;
6995 QEMUSnapshotInfo *sn_tab, *sn;
6996 int nb_sns, i;
6997 char buf[256];
6998
6999 bs = get_bs_snapshots();
7000 if (!bs) {
7001 term_printf("No available block device supports snapshots\n");
7002 return;
7003 }
7004 term_printf("Snapshot devices:");
e4bcb14c
TS		 7005 for(i = 0; i <= nb_drives; i++) {
7006 bs1 = drives_table[i].bdrv;
faea38e7
FB		 7007 if (bdrv_has_snapshot(bs1)) {
7008 if (bs == bs1)
7009 term_printf(" %s", bdrv_get_device_name(bs1));
7010 }
7011 }
7012 term_printf("\n");
7013
7014 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
7015 if (nb_sns < 0) {
7016 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
7017 return;
7018 }
7019 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
7020 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
7021 for(i = 0; i < nb_sns; i++) {
7022 sn = &sn_tab[i];
7023 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
7024 }
7025 qemu_free(sn_tab);
8a7ddc38
FB		 7026}
7027
8a7ddc38
FB		 7028/***********************************************************/
7029/* ram save/restore */
7030
8a7ddc38
FB		 7031static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
7032{
7033 int v;
7034
7035 v = qemu_get_byte(f);
7036 switch(v) {
7037 case 0:
7038 if (qemu_get_buffer(f, buf, len) != len)
7039 return -EIO;
7040 break;
7041 case 1:
7042 v = qemu_get_byte(f);
7043 memset(buf, v, len);
7044 break;
7045 default:
7046 return -EINVAL;
7047 }
7048 return 0;
7049}
7050
c88676f8
FB		 7051static int ram_load_v1(QEMUFile *f, void *opaque)
7052{
00f82b8a
AJ		 7053 int ret;
7054 ram_addr_t i;
c88676f8
FB		 7055
7056 if (qemu_get_be32(f) != phys_ram_size)
7057 return -EINVAL;
7058 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
7059 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
7060 if (ret)
7061 return ret;
7062 }
7063 return 0;
7064}
7065
7066#define BDRV_HASH_BLOCK_SIZE 1024
7067#define IOBUF_SIZE 4096
7068#define RAM_CBLOCK_MAGIC 0xfabe
7069
7070typedef struct RamCompressState {
7071 z_stream zstream;
7072 QEMUFile *f;
7073 uint8_t buf[IOBUF_SIZE];
7074} RamCompressState;
7075
7076static int ram_compress_open(RamCompressState *s, QEMUFile *f)
7077{
7078 int ret;
7079 memset(s, 0, sizeof(*s));
7080 s->f = f;
7081 ret = deflateInit2(&s->zstream, 1,
5fafdf24 7082 Z_DEFLATED, 15,
c88676f8
FB		 7083 9, Z_DEFAULT_STRATEGY);
7084 if (ret != Z_OK)
7085 return -1;
7086 s->zstream.avail_out = IOBUF_SIZE;
7087 s->zstream.next_out = s->buf;
7088 return 0;
7089}
7090
7091static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
7092{
7093 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
7094 qemu_put_be16(s->f, len);
7095 qemu_put_buffer(s->f, buf, len);
7096}
7097
7098static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
7099{
7100 int ret;
7101
7102 s->zstream.avail_in = len;
7103 s->zstream.next_in = (uint8_t *)buf;
7104 while (s->zstream.avail_in > 0) {
7105 ret = deflate(&s->zstream, Z_NO_FLUSH);
7106 if (ret != Z_OK)
7107 return -1;
7108 if (s->zstream.avail_out == 0) {
7109 ram_put_cblock(s, s->buf, IOBUF_SIZE);
7110 s->zstream.avail_out = IOBUF_SIZE;
7111 s->zstream.next_out = s->buf;
7112 }
7113 }
7114 return 0;
7115}
7116
7117static void ram_compress_close(RamCompressState *s)
7118{
7119 int len, ret;
7120
7121 /* compress last bytes */
7122 for(;;) {
7123 ret = deflate(&s->zstream, Z_FINISH);
7124 if (ret == Z_OK || ret == Z_STREAM_END) {
7125 len = IOBUF_SIZE - s->zstream.avail_out;
7126 if (len > 0) {
7127 ram_put_cblock(s, s->buf, len);
7128 }
7129 s->zstream.avail_out = IOBUF_SIZE;
7130 s->zstream.next_out = s->buf;
7131 if (ret == Z_STREAM_END)
7132 break;
7133 } else {
7134 goto fail;
7135 }
7136 }
7137fail:
7138 deflateEnd(&s->zstream);
7139}
7140
7141typedef struct RamDecompressState {
7142 z_stream zstream;
7143 QEMUFile *f;
7144 uint8_t buf[IOBUF_SIZE];
7145} RamDecompressState;
7146
7147static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
7148{
7149 int ret;
7150 memset(s, 0, sizeof(*s));
7151 s->f = f;
7152 ret = inflateInit(&s->zstream);
7153 if (ret != Z_OK)
7154 return -1;
7155 return 0;
7156}
7157
7158static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
7159{
7160 int ret, clen;
7161
7162 s->zstream.avail_out = len;
7163 s->zstream.next_out = buf;
7164 while (s->zstream.avail_out > 0) {
7165 if (s->zstream.avail_in == 0) {
7166 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
7167 return -1;
7168 clen = qemu_get_be16(s->f);
7169 if (clen > IOBUF_SIZE)
7170 return -1;
7171 qemu_get_buffer(s->f, s->buf, clen);
7172 s->zstream.avail_in = clen;
7173 s->zstream.next_in = s->buf;
7174 }
7175 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
7176 if (ret != Z_OK && ret != Z_STREAM_END) {
7177 return -1;
7178 }
7179 }
7180 return 0;
7181}
7182
7183static void ram_decompress_close(RamDecompressState *s)
7184{
7185 inflateEnd(&s->zstream);
7186}
7187
8a7ddc38
FB		 7188static void ram_save(QEMUFile *f, void *opaque)
7189{
00f82b8a 7190 ram_addr_t i;
c88676f8
FB		 7191 RamCompressState s1, *s = &s1;
7192 uint8_t buf[10];
3b46e624 7193
8a7ddc38 7194 qemu_put_be32(f, phys_ram_size);
c88676f8
FB		 7195 if (ram_compress_open(s, f) < 0)
7196 return;
7197 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7198#if 0
7199 if (tight_savevm_enabled) {
7200 int64_t sector_num;
7201 int j;
7202
7203 /* find if the memory block is available on a virtual
7204 block device */
7205 sector_num = -1;
e4bcb14c
TS		 7206 for(j = 0; j < nb_drives; j++) {
7207 sector_num = bdrv_hash_find(drives_table[j].bdrv,
7208 phys_ram_base + i,
7209 BDRV_HASH_BLOCK_SIZE);
7210 if (sector_num >= 0)
7211 break;
c88676f8 7212 }
e4bcb14c 7213 if (j == nb_drives)
c88676f8
FB		 7214 goto normal_compress;
7215 buf[0] = 1;
7216 buf[1] = j;
7217 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
7218 ram_compress_buf(s, buf, 10);
5fafdf24 7219 } else
c88676f8
FB		 7220#endif
7221 {
7222 // normal_compress:
7223 buf[0] = 0;
7224 ram_compress_buf(s, buf, 1);
7225 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7226 }
8a7ddc38 7227 }
c88676f8 7228 ram_compress_close(s);
8a7ddc38
FB		 7229}
7230
7231static int ram_load(QEMUFile *f, void *opaque, int version_id)
7232{
c88676f8
FB		 7233 RamDecompressState s1, *s = &s1;
7234 uint8_t buf[10];
00f82b8a 7235 ram_addr_t i;
8a7ddc38 7236
c88676f8
FB		 7237 if (version_id == 1)
7238 return ram_load_v1(f, opaque);
7239 if (version_id != 2)
8a7ddc38
FB		 7240 return -EINVAL;
7241 if (qemu_get_be32(f) != phys_ram_size)
7242 return -EINVAL;
c88676f8
FB		 7243 if (ram_decompress_open(s, f) < 0)
7244 return -EINVAL;
7245 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7246 if (ram_decompress_buf(s, buf, 1) < 0) {
7247 fprintf(stderr, "Error while reading ram block header\n");
7248 goto error;
7249 }
7250 if (buf[0] == 0) {
7251 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
00f82b8a 7252 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
c88676f8
FB		 7253 goto error;
7254 }
5fafdf24 7255 } else
c88676f8
FB		 7256#if 0
7257 if (buf[0] == 1) {
7258 int bs_index;
7259 int64_t sector_num;
7260
7261 ram_decompress_buf(s, buf + 1, 9);
7262 bs_index = buf[1];
7263 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
e4bcb14c 7264 if (bs_index >= nb_drives) {
c88676f8
FB		 7265 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7266 goto error;
7267 }
e4bcb14c
TS		 7268 if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7269 phys_ram_base + i,
c88676f8 7270 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
5fafdf24 7271 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
c88676f8
FB		 7272 bs_index, sector_num);
7273 goto error;
7274 }
5fafdf24 7275 } else
c88676f8
FB		 7276#endif
7277 {
7278 error:
7279 printf("Error block header\n");
7280 return -EINVAL;
7281 }
8a7ddc38 7282 }
c88676f8 7283 ram_decompress_close(s);
8a7ddc38
FB		 7284 return 0;
7285}
7286
83f64091
FB		 7287/***********************************************************/
7288/* bottom halves (can be seen as timers which expire ASAP) */
7289
7290struct QEMUBH {
7291 QEMUBHFunc *cb;
7292 void *opaque;
7293 int scheduled;
7294 QEMUBH *next;
7295};
7296
7297static QEMUBH *first_bh = NULL;
7298
7299QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7300{
7301 QEMUBH *bh;
7302 bh = qemu_mallocz(sizeof(QEMUBH));
7303 if (!bh)
7304 return NULL;
7305 bh->cb = cb;
7306 bh->opaque = opaque;
7307 return bh;
7308}
7309
6eb5733a 7310int qemu_bh_poll(void)
83f64091
FB		 7311{
7312 QEMUBH *bh, **pbh;
6eb5733a 7313 int ret;
83f64091 7314
6eb5733a 7315 ret = 0;
83f64091
FB		 7316 for(;;) {
7317 pbh = &first_bh;
7318 bh = *pbh;
7319 if (!bh)
7320 break;
6eb5733a 7321 ret = 1;
83f64091
FB		 7322 *pbh = bh->next;
7323 bh->scheduled = 0;
7324 bh->cb(bh->opaque);
7325 }
6eb5733a 7326 return ret;
83f64091
FB		 7327}
7328
7329void qemu_bh_schedule(QEMUBH *bh)
7330{
7331 CPUState *env = cpu_single_env;
7332 if (bh->scheduled)
7333 return;
7334 bh->scheduled = 1;
7335 bh->next = first_bh;
7336 first_bh = bh;
7337
7338 /* stop the currently executing CPU to execute the BH ASAP */
7339 if (env) {
7340 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7341 }
7342}
7343
7344void qemu_bh_cancel(QEMUBH *bh)
7345{
7346 QEMUBH **pbh;
7347 if (bh->scheduled) {
7348 pbh = &first_bh;
7349 while (*pbh != bh)
7350 pbh = &(*pbh)->next;
7351 *pbh = bh->next;
7352 bh->scheduled = 0;
7353 }
7354}
7355
7356void qemu_bh_delete(QEMUBH *bh)
7357{
7358 qemu_bh_cancel(bh);
7359 qemu_free(bh);
7360}
7361
cc1daa40
FB		 7362/***********************************************************/
7363/* machine registration */
7364
bdaf78e0 7365static QEMUMachine *first_machine = NULL;
cc1daa40
FB		 7366
7367int qemu_register_machine(QEMUMachine *m)
7368{
7369 QEMUMachine **pm;
7370 pm = &first_machine;
7371 while (*pm != NULL)
7372 pm = &(*pm)->next;
7373 m->next = NULL;
7374 *pm = m;
7375 return 0;
7376}
7377
9596ebb7 7378static QEMUMachine *find_machine(const char *name)
cc1daa40
FB		 7379{
7380 QEMUMachine *m;
7381
7382 for(m = first_machine; m != NULL; m = m->next) {
7383 if (!strcmp(m->name, name))
7384 return m;
7385 }
7386 return NULL;
7387}
7388
8a7ddc38
FB		 7389/***********************************************************/
7390/* main execution loop */
7391
9596ebb7 7392static void gui_update(void *opaque)
8a7ddc38 7393{
740733bb
TS		 7394 DisplayState *ds = opaque;
7395 ds->dpy_refresh(ds);
f442e08b
AJ		 7396 qemu_mod_timer(ds->gui_timer,
7397 (ds->gui_timer_interval ?
7398 ds->gui_timer_interval :
7399 GUI_REFRESH_INTERVAL)
7400 + qemu_get_clock(rt_clock));
8a7ddc38
FB		 7401}
7402
0bd48850
FB		 7403struct vm_change_state_entry {
7404 VMChangeStateHandler *cb;
7405 void *opaque;
7406 LIST_ENTRY (vm_change_state_entry) entries;
7407};
7408
7409static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7410
7411VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7412 void *opaque)
7413{
7414 VMChangeStateEntry *e;
7415
7416 e = qemu_mallocz(sizeof (*e));
7417 if (!e)
7418 return NULL;
7419
7420 e->cb = cb;
7421 e->opaque = opaque;
7422 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7423 return e;
7424}
7425
7426void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7427{
7428 LIST_REMOVE (e, entries);
7429 qemu_free (e);
7430}
7431
7432static void vm_state_notify(int running)
7433{
7434 VMChangeStateEntry *e;
7435
7436 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7437 e->cb(e->opaque, running);
7438 }
7439}
7440
8a7ddc38 7441/* XXX: support several handlers */
0bd48850
FB		 7442static VMStopHandler *vm_stop_cb;
7443static void *vm_stop_opaque;
8a7ddc38
FB		 7444
7445int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7446{
7447 vm_stop_cb = cb;
7448 vm_stop_opaque = opaque;
7449 return 0;
7450}
7451
7452void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7453{
7454 vm_stop_cb = NULL;
7455}
7456
7457void vm_start(void)
7458{
7459 if (!vm_running) {
7460 cpu_enable_ticks();
7461 vm_running = 1;
0bd48850 7462 vm_state_notify(1);
efe75411 7463 qemu_rearm_alarm_timer(alarm_timer);
8a7ddc38
FB		 7464 }
7465}
7466
5fafdf24 7467void vm_stop(int reason)
8a7ddc38
FB		 7468{
7469 if (vm_running) {
7470 cpu_disable_ticks();
7471 vm_running = 0;
7472 if (reason != 0) {
7473 if (vm_stop_cb) {
7474 vm_stop_cb(vm_stop_opaque, reason);
7475 }
34865134 7476 }
0bd48850 7477 vm_state_notify(0);
8a7ddc38
FB		 7478 }
7479}
7480
bb0c6722
FB		 7481/* reset/shutdown handler */
7482
7483typedef struct QEMUResetEntry {
7484 QEMUResetHandler *func;
7485 void *opaque;
7486 struct QEMUResetEntry *next;
7487} QEMUResetEntry;
7488
7489static QEMUResetEntry *first_reset_entry;
7490static int reset_requested;
7491static int shutdown_requested;
3475187d 7492static int powerdown_requested;
bb0c6722 7493
cf7a2fe2
AJ		 7494int qemu_shutdown_requested(void)
7495{
7496 int r = shutdown_requested;
7497 shutdown_requested = 0;
7498 return r;
7499}
7500
7501int qemu_reset_requested(void)
7502{
7503 int r = reset_requested;
7504 reset_requested = 0;
7505 return r;
7506}
7507
7508int qemu_powerdown_requested(void)
7509{
7510 int r = powerdown_requested;
7511 powerdown_requested = 0;
7512 return r;
7513}
7514
bb0c6722
FB		 7515void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7516{
7517 QEMUResetEntry **pre, *re;
7518
7519 pre = &first_reset_entry;
7520 while (*pre != NULL)
7521 pre = &(*pre)->next;
7522 re = qemu_mallocz(sizeof(QEMUResetEntry));
7523 re->func = func;
7524 re->opaque = opaque;
7525 re->next = NULL;
7526 *pre = re;
7527}
7528
cf7a2fe2 7529void qemu_system_reset(void)
bb0c6722
FB		 7530{
7531 QEMUResetEntry *re;
7532
7533 /* reset all devices */
7534 for(re = first_reset_entry; re != NULL; re = re->next) {
7535 re->func(re->opaque);
7536 }
7537}
7538
7539void qemu_system_reset_request(void)
7540{
d1beab82
FB		 7541 if (no_reboot) {
7542 shutdown_requested = 1;
7543 } else {
7544 reset_requested = 1;
7545 }
6a00d601
FB		 7546 if (cpu_single_env)
7547 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7548}
7549
7550void qemu_system_shutdown_request(void)
7551{
7552 shutdown_requested = 1;
6a00d601
FB		 7553 if (cpu_single_env)
7554 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7555}
7556
3475187d
FB		 7557void qemu_system_powerdown_request(void)
7558{
7559 powerdown_requested = 1;
6a00d601
FB		 7560 if (cpu_single_env)
7561 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7562}
7563
5905b2e5 7564void main_loop_wait(int timeout)
8a7ddc38 7565{
cafffd40 7566 IOHandlerRecord *ioh;
e035649e 7567 fd_set rfds, wfds, xfds;
877cf882
TS		 7568 int ret, nfds;
7569#ifdef _WIN32
7570 int ret2, i;
7571#endif
fd1dff4b 7572 struct timeval tv;
f331110f
FB		 7573 PollingEntry *pe;
7574
c4b1fcc0 7575
f331110f
FB		 7576 /* XXX: need to suppress polling by better using win32 events */
7577 ret = 0;
7578 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7579 ret |= pe->func(pe->opaque);
7580 }
38e205a2 7581#ifdef _WIN32
e6b1e558 7582 if (ret == 0) {
a18e524a
FB		 7583 int err;
7584 WaitObjects *w = &wait_objects;
3b46e624 7585
a18e524a
FB		 7586 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7587 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7588 if (w->func[ret - WAIT_OBJECT_0])
7589 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3b46e624 7590
5fafdf24 7591 /* Check for additional signaled events */
e6b1e558 7592 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3b46e624 7593
e6b1e558
TS		 7594 /* Check if event is signaled */
7595 ret2 = WaitForSingleObject(w->events[i], 0);
7596 if(ret2 == WAIT_OBJECT_0) {
7597 if (w->func[i])
7598 w->func[i](w->opaque[i]);
7599 } else if (ret2 == WAIT_TIMEOUT) {
7600 } else {
7601 err = GetLastError();
7602 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3b46e624
TS		 7603 }
7604 }
a18e524a
FB		 7605 } else if (ret == WAIT_TIMEOUT) {
7606 } else {
7607 err = GetLastError();
e6b1e558 7608 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
a18e524a 7609 }
f331110f 7610 }
fd1dff4b
FB		 7611#endif
7612 /* poll any events */
7613 /* XXX: separate device handlers from system ones */
7614 nfds = -1;
7615 FD_ZERO(&rfds);
7616 FD_ZERO(&wfds);
e035649e 7617 FD_ZERO(&xfds);
fd1dff4b 7618 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
cafffd40
TS		 7619 if (ioh->deleted)
7620 continue;
fd1dff4b
FB		 7621 if (ioh->fd_read &&
7622 (!ioh->fd_read_poll ||
7623 ioh->fd_read_poll(ioh->opaque) != 0)) {
7624 FD_SET(ioh->fd, &rfds);
7625 if (ioh->fd > nfds)
7626 nfds = ioh->fd;
7627 }
7628 if (ioh->fd_write) {
7629 FD_SET(ioh->fd, &wfds);
7630 if (ioh->fd > nfds)
7631 nfds = ioh->fd;
7632 }
7633 }
3b46e624 7634
fd1dff4b
FB		 7635 tv.tv_sec = 0;
7636#ifdef _WIN32
7637 tv.tv_usec = 0;
38e205a2 7638#else
fd1dff4b
FB		 7639 tv.tv_usec = timeout * 1000;
7640#endif
e035649e
FB		 7641#if defined(CONFIG_SLIRP)
7642 if (slirp_inited) {
7643 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7644 }
7645#endif
7646 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
fd1dff4b 7647 if (ret > 0) {
cafffd40
TS		 7648 IOHandlerRecord **pioh;
7649
7650 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6ab43fdc 7651 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
fd1dff4b 7652 ioh->fd_read(ioh->opaque);
7c9d8e07 7653 }
6ab43fdc 7654 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
fd1dff4b 7655 ioh->fd_write(ioh->opaque);
c4b1fcc0 7656 }
b4608c04 7657 }
cafffd40
TS		 7658
7659 /* remove deleted IO handlers */
7660 pioh = &first_io_handler;
7661 while (*pioh) {
7662 ioh = *pioh;
7663 if (ioh->deleted) {
7664 *pioh = ioh->next;
7665 qemu_free(ioh);
5fafdf24 7666 } else
cafffd40
TS		 7667 pioh = &ioh->next;
7668 }
fd1dff4b 7669 }
c20709aa 7670#if defined(CONFIG_SLIRP)
fd1dff4b 7671 if (slirp_inited) {
e035649e
FB		 7672 if (ret < 0) {
7673 FD_ZERO(&rfds);
7674 FD_ZERO(&wfds);
7675 FD_ZERO(&xfds);
c20709aa 7676 }
e035649e 7677 slirp_select_poll(&rfds, &wfds, &xfds);
fd1dff4b 7678 }
e035649e 7679#endif
b4608c04 7680
fd1dff4b 7681 if (vm_running) {
21b20814 7682 if (likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
5fafdf24 7683 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
fd1dff4b
FB		 7684 qemu_get_clock(vm_clock));
7685 /* run dma transfers, if any */
7686 DMA_run();
7687 }
423f0742 7688
fd1dff4b 7689 /* real time timers */
5fafdf24 7690 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
fd1dff4b 7691 qemu_get_clock(rt_clock));
423f0742 7692
d5d08334
AZ		 7693 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7694 alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7695 qemu_rearm_alarm_timer(alarm_timer);
7696 }
b99dc0d1 7697
423f0742
PB		 7698 /* Check bottom-halves last in case any of the earlier events triggered
7699 them. */
7700 qemu_bh_poll();
3b46e624 7701
5905b2e5
FB		 7702}
7703
9596ebb7 7704static int main_loop(void)
5905b2e5
FB		 7705{
7706 int ret, timeout;
89bfc105
FB		 7707#ifdef CONFIG_PROFILER
7708 int64_t ti;
7709#endif
6a00d601 7710 CPUState *env;
5905b2e5 7711
6a00d601 7712 cur_cpu = first_cpu;
ee5605e5 7713 next_cpu = cur_cpu->next_cpu ?: first_cpu;
5905b2e5
FB		 7714 for(;;) {
7715 if (vm_running) {
15a76449 7716
15a76449
FB		 7717 for(;;) {
7718 /* get next cpu */
ee5605e5 7719 env = next_cpu;
89bfc105
FB		 7720#ifdef CONFIG_PROFILER
7721 ti = profile_getclock();
7722#endif
2e70f6ef
PB		 7723 if (use_icount) {
7724 int64_t count;
7725 int decr;
7726 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
7727 env->icount_decr.u16.low = 0;
7728 env->icount_extra = 0;
7729 count = qemu_next_deadline();
7730 count = (count + (1 << icount_time_shift) - 1)
7731 >> icount_time_shift;
7732 qemu_icount += count;
7733 decr = (count > 0xffff) ? 0xffff : count;
7734 count -= decr;
7735 env->icount_decr.u16.low = decr;
7736 env->icount_extra = count;
7737 }
6a00d601 7738 ret = cpu_exec(env);
89bfc105
FB		 7739#ifdef CONFIG_PROFILER
7740 qemu_time += profile_getclock() - ti;
7741#endif
2e70f6ef
PB		 7742 if (use_icount) {
7743 /* Fold pending instructions back into the
7744 instruction counter, and clear the interrupt flag. */
7745 qemu_icount -= (env->icount_decr.u16.low
7746 + env->icount_extra);
7747 env->icount_decr.u32 = 0;
7748 env->icount_extra = 0;
7749 }
ee5605e5 7750 next_cpu = env->next_cpu ?: first_cpu;
95b01009 7751 if (event_pending && likely(ret != EXCP_DEBUG)) {
ee5605e5
AZ		 7752 ret = EXCP_INTERRUPT;
7753 event_pending = 0;
7754 break;
7755 }
bd967e05
PB		 7756 if (ret == EXCP_HLT) {
7757 /* Give the next CPU a chance to run. */
7758 cur_cpu = env;
7759 continue;
7760 }
15a76449
FB		 7761 if (ret != EXCP_HALTED)
7762 break;
7763 /* all CPUs are halted ? */
bd967e05 7764 if (env == cur_cpu)
15a76449 7765 break;
15a76449
FB		 7766 }
7767 cur_cpu = env;
7768
5905b2e5 7769 if (shutdown_requested) {
3475187d 7770 ret = EXCP_INTERRUPT;
b2f76161
AJ		 7771 if (no_shutdown) {
7772 vm_stop(0);
7773 no_shutdown = 0;
7774 }
7775 else
7776 break;
5905b2e5
FB		 7777 }
7778 if (reset_requested) {
7779 reset_requested = 0;
7780 qemu_system_reset();
3475187d
FB		 7781 ret = EXCP_INTERRUPT;
7782 }
7783 if (powerdown_requested) {
7784 powerdown_requested = 0;
7785 qemu_system_powerdown();
7786 ret = EXCP_INTERRUPT;
5905b2e5 7787 }
95b01009 7788 if (unlikely(ret == EXCP_DEBUG)) {
5905b2e5
FB		 7789 vm_stop(EXCP_DEBUG);
7790 }
bd967e05 7791 /* If all cpus are halted then wait until the next IRQ */
5905b2e5 7792 /* XXX: use timeout computed from timers */
2e70f6ef
PB		 7793 if (ret == EXCP_HALTED) {
7794 if (use_icount) {
7795 int64_t add;
7796 int64_t delta;
7797 /* Advance virtual time to the next event. */
7798 if (use_icount == 1) {
7799 /* When not using an adaptive execution frequency
7800 we tend to get badly out of sync with real time,
bf20dc07 7801 so just delay for a reasonable amount of time. */
2e70f6ef
PB		 7802 delta = 0;
7803 } else {
7804 delta = cpu_get_icount() - cpu_get_clock();
7805 }
7806 if (delta > 0) {
7807 /* If virtual time is ahead of real time then just
7808 wait for IO. */
7809 timeout = (delta / 1000000) + 1;
7810 } else {
7811 /* Wait for either IO to occur or the next
7812 timer event. */
7813 add = qemu_next_deadline();
7814 /* We advance the timer before checking for IO.
7815 Limit the amount we advance so that early IO
7816 activity won't get the guest too far ahead. */
7817 if (add > 10000000)
7818 add = 10000000;
7819 delta += add;
7820 add = (add + (1 << icount_time_shift) - 1)
7821 >> icount_time_shift;
7822 qemu_icount += add;
7823 timeout = delta / 1000000;
7824 if (timeout < 0)
7825 timeout = 0;
7826 }
7827 } else {
7828 timeout = 10;
7829 }
7830 } else {
5905b2e5 7831 timeout = 0;
2e70f6ef 7832 }
5905b2e5 7833 } else {
98448f58
BS		 7834 if (shutdown_requested) {
7835 ret = EXCP_INTERRUPT;
5b08fc10 7836 break;
98448f58 7837 }
5905b2e5
FB		 7838 timeout = 10;
7839 }
89bfc105
FB		 7840#ifdef CONFIG_PROFILER
7841 ti = profile_getclock();
7842#endif
5905b2e5 7843 main_loop_wait(timeout);
89bfc105
FB		 7844#ifdef CONFIG_PROFILER
7845 dev_time += profile_getclock() - ti;
7846#endif
b4608c04 7847 }
34865134
FB		 7848 cpu_disable_ticks();
7849 return ret;
b4608c04
FB		 7850}
7851
15f82208 7852static void help(int exitcode)
0824d6fc 7853{
68d0f70e 7854 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
0db63474 7855 "usage: %s [options] [disk_image]\n"
0824d6fc 7856 "\n"
a20dd508 7857 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
fc01f7e7 7858 "\n"
a20dd508 7859 "Standard options:\n"
cc1daa40 7860 "-M machine select emulated machine (-M ? for list)\n"
5adb4839 7861 "-cpu cpu select CPU (-cpu ? for list)\n"
c45886db 7862 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
36b486bb
FB		 7863 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7864 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
c4b1fcc0 7865 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
a1620fac
AJ		 7866 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7867 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7868 " [,cache=on|off][,format=f]\n"
e4bcb14c 7869 " use 'file' as a drive image\n"
3e3d5815 7870 "-mtdblock file use 'file' as on-board Flash memory image\n"
a1bb27b1 7871 "-sd file use 'file' as SecureDigital card image\n"
86f55663 7872 "-pflash file use 'file' as a parallel flash image\n"
eec85c2a 7873 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
667accab
TS		 7874 "-snapshot write to temporary files instead of disk image files\n"
7875#ifdef CONFIG_SDL
43523e93 7876 "-no-frame open SDL window without a frame and window decorations\n"
3780e197 7877 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
667accab
TS		 7878 "-no-quit disable SDL window close capability\n"
7879#endif
52ca8d6a
FB		 7880#ifdef TARGET_I386
7881 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7882#endif
a00bad7e 7883 "-m megs set virtual RAM size to megs MB [default=%d]\n"
91fc2119 7884 "-smp n set the number of CPUs to 'n' [default=1]\n"
c4b1fcc0 7885 "-nographic disable graphical output and redirect serial I/Os to console\n"
a171fe39 7886 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
4ca0074c 7887#ifndef _WIN32
667accab 7888 "-k language use keyboard layout (for example \"fr\" for French)\n"
4ca0074c 7889#endif
1d14ffa9 7890#ifdef HAS_AUDIO
1d14ffa9 7891 "-audio-help print list of audio drivers and their options\n"
c0fe3827
FB		 7892 "-soundhw c1,... enable audio support\n"
7893 " and only specified sound cards (comma separated list)\n"
7894 " use -soundhw ? to get the list of supported cards\n"
6a36d84e 7895 " use -soundhw all to enable all of them\n"
1d14ffa9 7896#endif
3893c124 7897 "-vga [std|cirrus|vmware]\n"
7898 " select video card type\n"
89980284 7899 "-localtime set the real time clock to local time [default=utc]\n"
d63d307f 7900 "-full-screen start in full screen\n"
a09db21f
FB		 7901#ifdef TARGET_I386
7902 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7903#endif
b389dbfb
FB		 7904 "-usb enable the USB driver (will be the default soon)\n"
7905 "-usbdevice name add the host or guest USB device 'name'\n"
6f7e9aec
FB		 7906#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7907 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
bb0c6722 7908#endif
c35734b2 7909 "-name string set the name of the guest\n"
8fcb1b90 7910 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
c4b1fcc0
FB		 7911 "\n"
7912 "Network options:\n"
a41b2ff2 7913 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7c9d8e07 7914 " create a new Network Interface Card and connect it to VLAN 'n'\n"
c20709aa 7915#ifdef CONFIG_SLIRP
115defd1
PB		 7916 "-net user[,vlan=n][,hostname=host]\n"
7917 " connect the user mode network stack to VLAN 'n' and send\n"
7918 " hostname 'host' to DHCP clients\n"
7c9d8e07 7919#endif
7fb843f8
FB		 7920#ifdef _WIN32
7921 "-net tap[,vlan=n],ifname=name\n"
7922 " connect the host TAP network interface to VLAN 'n'\n"
7923#else
b46a8906
TS		 7924 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7925 " connect the host TAP network interface to VLAN 'n' and use the\n"
7926 " network scripts 'file' (default=%s)\n"
7927 " and 'dfile' (default=%s);\n"
7928 " use '[down]script=no' to disable script execution;\n"
7c9d8e07 7929 " use 'fd=h' to connect to an already opened TAP interface\n"
7fb843f8 7930#endif
6a00d601 7931 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7c9d8e07 7932 " connect the vlan 'n' to another VLAN using a socket connection\n"
3d830459
FB		 7933 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7934 " connect the vlan 'n' to multicast maddr and port\n"
8a16d273
TS		 7935#ifdef CONFIG_VDE
7936 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
7937 " connect the vlan 'n' to port 'n' of a vde switch running\n"
7938 " on host and listening for incoming connections on 'socketpath'.\n"
7939 " Use group 'groupname' and mode 'octalmode' to change default\n"
7940 " ownership and permissions for communication port.\n"
7941#endif
7c9d8e07
FB		 7942 "-net none use it alone to have zero network devices; if no -net option\n"
7943 " is provided, the default is '-net nic -net user'\n"
7944 "\n"
7945#ifdef CONFIG_SLIRP
0db1137d 7946 "-tftp dir allow tftp access to files in dir [-net user]\n"
47d5d01a 7947 "-bootp file advertise file in BOOTP replies\n"
7c9d8e07
FB		 7948#ifndef _WIN32
7949 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
c94c8d64 7950#endif
9bf05444 7951 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7c9d8e07 7952 " redirect TCP or UDP connections from host to guest [-net user]\n"
c20709aa 7953#endif
a20dd508 7954 "\n"
c4b1fcc0 7955 "Linux boot specific:\n"
a20dd508
FB		 7956 "-kernel bzImage use 'bzImage' as kernel image\n"
7957 "-append cmdline use 'cmdline' as kernel command line\n"
7958 "-initrd file use 'file' as initial ram disk\n"
fc01f7e7 7959 "\n"
330d0414 7960 "Debug/Expert options:\n"
82c643ff
FB		 7961 "-monitor dev redirect the monitor to char device 'dev'\n"
7962 "-serial dev redirect the serial port to char device 'dev'\n"
6508fe59 7963 "-parallel dev redirect the parallel port to char device 'dev'\n"
f7cce898 7964 "-pidfile file Write PID to 'file'\n"
cd6f1169 7965 "-S freeze CPU at startup (use 'c' to start execution)\n"
cfc3475a
PB		 7966 "-s wait gdb connection to port\n"
7967 "-p port set gdb connection port [default=%s]\n"
f193c797 7968 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
46d4767d
FB		 7969 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7970 " translation (t=none or lba) (usually qemu can guess them)\n"
87b47350 7971 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
d993e026 7972#ifdef USE_KQEMU
6515b203 7973 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
d993e026
FB		 7974 "-no-kqemu disable KQEMU kernel module usage\n"
7975#endif
bb0c6722 7976#ifdef TARGET_I386
6515b203 7977 "-no-acpi disable ACPI\n"
4d3b6f6e
AZ		 7978#endif
7979#ifdef CONFIG_CURSES
7980 "-curses use a curses/ncurses interface instead of SDL\n"
bb0c6722 7981#endif
d1beab82 7982 "-no-reboot exit instead of rebooting\n"
b2f76161 7983 "-no-shutdown stop before shutdown\n"
a8080006 7984 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
24236869 7985 "-vnc display start a VNC server on display\n"
71e3ceb8
TS		 7986#ifndef _WIN32
7987 "-daemonize daemonize QEMU after initializing\n"
7988#endif
9ae02555 7989 "-option-rom rom load a file, rom, into the option ROM space\n"
66508601
BS		 7990#ifdef TARGET_SPARC
7991 "-prom-env variable=value set OpenBIOS nvram variables\n"
7992#endif
f3dcfada 7993 "-clock force the use of the given methods for timer alarm.\n"
3adda04c 7994 " To see what timers are available use -clock ?\n"
bce61846 7995 "-startdate select initial date of the clock\n"
2e70f6ef 7996 "-icount [N|auto]\n"
dd5d6fe9 7997 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
0824d6fc 7998 "\n"
82c643ff 7999 "During emulation, the following keys are useful:\n"
032a8c9e
FB		 8000 "ctrl-alt-f toggle full screen\n"
8001 "ctrl-alt-n switch to virtual console 'n'\n"
8002 "ctrl-alt toggle mouse and keyboard grab\n"
82c643ff
FB		 8003 "\n"
8004 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8005 ,
0db63474 8006 "qemu",
a00bad7e 8007 DEFAULT_RAM_SIZE,
7c9d8e07 8008#ifndef _WIN32
a00bad7e 8009 DEFAULT_NETWORK_SCRIPT,
b46a8906 8010 DEFAULT_NETWORK_DOWN_SCRIPT,
7c9d8e07 8011#endif
6e44ba7f 8012 DEFAULT_GDBSTUB_PORT,
bce61846 8013 "/tmp/qemu.log");
15f82208 8014 exit(exitcode);
0824d6fc
FB		 8015}
8016
cd6f1169
FB		 8017#define HAS_ARG 0x0001
8018
8019enum {
8020 QEMU_OPTION_h,
8021
cc1daa40 8022 QEMU_OPTION_M,
94fc95cd 8023 QEMU_OPTION_cpu,
cd6f1169
FB		 8024 QEMU_OPTION_fda,
8025 QEMU_OPTION_fdb,
8026 QEMU_OPTION_hda,
8027 QEMU_OPTION_hdb,
8028 QEMU_OPTION_hdc,
8029 QEMU_OPTION_hdd,
e4bcb14c 8030 QEMU_OPTION_drive,
cd6f1169 8031 QEMU_OPTION_cdrom,
3e3d5815 8032 QEMU_OPTION_mtdblock,
a1bb27b1 8033 QEMU_OPTION_sd,
86f55663 8034 QEMU_OPTION_pflash,
cd6f1169
FB		 8035 QEMU_OPTION_boot,
8036 QEMU_OPTION_snapshot,
52ca8d6a
FB		 8037#ifdef TARGET_I386
8038 QEMU_OPTION_no_fd_bootchk,
8039#endif
cd6f1169
FB		 8040 QEMU_OPTION_m,
8041 QEMU_OPTION_nographic,
a171fe39 8042 QEMU_OPTION_portrait,
1d14ffa9 8043#ifdef HAS_AUDIO
1d14ffa9
FB		 8044 QEMU_OPTION_audio_help,
8045 QEMU_OPTION_soundhw,
8046#endif
cd6f1169 8047
7c9d8e07 8048 QEMU_OPTION_net,
c7f74643 8049 QEMU_OPTION_tftp,
47d5d01a 8050 QEMU_OPTION_bootp,
9d728e8c 8051 QEMU_OPTION_smb,
9bf05444 8052 QEMU_OPTION_redir,
cd6f1169
FB		 8053
8054 QEMU_OPTION_kernel,
8055 QEMU_OPTION_append,
8056 QEMU_OPTION_initrd,
8057
8058 QEMU_OPTION_S,
8059 QEMU_OPTION_s,
8060 QEMU_OPTION_p,
8061 QEMU_OPTION_d,
8062 QEMU_OPTION_hdachs,
8063 QEMU_OPTION_L,
1192dad8 8064 QEMU_OPTION_bios,
3d11d0eb 8065 QEMU_OPTION_k,
ee22c2f7 8066 QEMU_OPTION_localtime,
e9b137c2 8067 QEMU_OPTION_g,
3893c124 8068 QEMU_OPTION_vga,
20d8a3ed 8069 QEMU_OPTION_echr,
82c643ff
FB		 8070 QEMU_OPTION_monitor,
8071 QEMU_OPTION_serial,
6508fe59 8072 QEMU_OPTION_parallel,
d63d307f
FB		 8073 QEMU_OPTION_loadvm,
8074 QEMU_OPTION_full_screen,
43523e93 8075 QEMU_OPTION_no_frame,
3780e197 8076 QEMU_OPTION_alt_grab,
667accab 8077 QEMU_OPTION_no_quit,
f7cce898 8078 QEMU_OPTION_pidfile,
d993e026 8079 QEMU_OPTION_no_kqemu,
89bfc105 8080 QEMU_OPTION_kernel_kqemu,
a09db21f 8081 QEMU_OPTION_win2k_hack,
bb36d470 8082 QEMU_OPTION_usb,
a594cfbf 8083 QEMU_OPTION_usbdevice,
6a00d601 8084 QEMU_OPTION_smp,
24236869 8085 QEMU_OPTION_vnc,
6515b203 8086 QEMU_OPTION_no_acpi,
4d3b6f6e 8087 QEMU_OPTION_curses,
d1beab82 8088 QEMU_OPTION_no_reboot,
b2f76161 8089 QEMU_OPTION_no_shutdown,
9467cd46 8090 QEMU_OPTION_show_cursor,
71e3ceb8 8091 QEMU_OPTION_daemonize,
9ae02555 8092 QEMU_OPTION_option_rom,
c35734b2
TS		 8093 QEMU_OPTION_semihosting,
8094 QEMU_OPTION_name,
66508601 8095 QEMU_OPTION_prom_env,
2b8f2d41 8096 QEMU_OPTION_old_param,
f3dcfada 8097 QEMU_OPTION_clock,
7e0af5d0 8098 QEMU_OPTION_startdate,
26a5f13b 8099 QEMU_OPTION_tb_size,
2e70f6ef 8100 QEMU_OPTION_icount,
8fcb1b90 8101 QEMU_OPTION_uuid,
cd6f1169
FB		 8102};
8103
8104typedef struct QEMUOption {
8105 const char *name;
8106 int flags;
8107 int index;
8108} QEMUOption;
8109
dbed7e40 8110static const QEMUOption qemu_options[] = {
cd6f1169 8111 { "h", 0, QEMU_OPTION_h },
64423fb2 8112 { "help", 0, QEMU_OPTION_h },
cd6f1169 8113
cc1daa40 8114 { "M", HAS_ARG, QEMU_OPTION_M },
94fc95cd 8115 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
cd6f1169
FB		 8116 { "fda", HAS_ARG, QEMU_OPTION_fda },
8117 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
8118 { "hda", HAS_ARG, QEMU_OPTION_hda },
8119 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
8120 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
8121 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
e4bcb14c 8122 { "drive", HAS_ARG, QEMU_OPTION_drive },
cd6f1169 8123 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
3e3d5815 8124 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
a1bb27b1 8125 { "sd", HAS_ARG, QEMU_OPTION_sd },
86f55663 8126 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
cd6f1169
FB		 8127 { "boot", HAS_ARG, QEMU_OPTION_boot },
8128 { "snapshot", 0, QEMU_OPTION_snapshot },
52ca8d6a
FB		 8129#ifdef TARGET_I386
8130 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
8131#endif
cd6f1169
FB		 8132 { "m", HAS_ARG, QEMU_OPTION_m },
8133 { "nographic", 0, QEMU_OPTION_nographic },
a171fe39 8134 { "portrait", 0, QEMU_OPTION_portrait },
3d11d0eb 8135 { "k", HAS_ARG, QEMU_OPTION_k },
1d14ffa9 8136#ifdef HAS_AUDIO
1d14ffa9
FB		 8137 { "audio-help", 0, QEMU_OPTION_audio_help },
8138 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
8139#endif
cd6f1169 8140
7c9d8e07 8141 { "net", HAS_ARG, QEMU_OPTION_net},
158156d1 8142#ifdef CONFIG_SLIRP
c7f74643 8143 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
47d5d01a 8144 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
c94c8d64 8145#ifndef _WIN32
9d728e8c 8146 { "smb", HAS_ARG, QEMU_OPTION_smb },
c94c8d64 8147#endif
9bf05444 8148 { "redir", HAS_ARG, QEMU_OPTION_redir },
158156d1 8149#endif
cd6f1169
FB		 8150
8151 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
8152 { "append", HAS_ARG, QEMU_OPTION_append },
8153 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
8154
8155 { "S", 0, QEMU_OPTION_S },
8156 { "s", 0, QEMU_OPTION_s },
8157 { "p", HAS_ARG, QEMU_OPTION_p },
8158 { "d", HAS_ARG, QEMU_OPTION_d },
8159 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
8160 { "L", HAS_ARG, QEMU_OPTION_L },
1192dad8 8161 { "bios", HAS_ARG, QEMU_OPTION_bios },
d993e026
FB		 8162#ifdef USE_KQEMU
8163 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
89bfc105 8164 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
d993e026 8165#endif
6f7e9aec 8166#if defined(TARGET_PPC) || defined(TARGET_SPARC)
e9b137c2 8167 { "g", 1, QEMU_OPTION_g },
77d4bc34 8168#endif
ee22c2f7 8169 { "localtime", 0, QEMU_OPTION_localtime },
3893c124 8170 { "vga", HAS_ARG, QEMU_OPTION_vga },
8b6e0729
AZ		 8171 { "echr", HAS_ARG, QEMU_OPTION_echr },
8172 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
8173 { "serial", HAS_ARG, QEMU_OPTION_serial },
8174 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
d63d307f
FB		 8175 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
8176 { "full-screen", 0, QEMU_OPTION_full_screen },
667accab 8177#ifdef CONFIG_SDL
43523e93 8178 { "no-frame", 0, QEMU_OPTION_no_frame },
3780e197 8179 { "alt-grab", 0, QEMU_OPTION_alt_grab },
667accab
TS		 8180 { "no-quit", 0, QEMU_OPTION_no_quit },
8181#endif
f7cce898 8182 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
a09db21f 8183 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
a594cfbf 8184 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6a00d601 8185 { "smp", HAS_ARG, QEMU_OPTION_smp },
24236869 8186 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4d3b6f6e
AZ		 8187#ifdef CONFIG_CURSES
8188 { "curses", 0, QEMU_OPTION_curses },
8189#endif
8fcb1b90 8190 { "uuid", HAS_ARG, QEMU_OPTION_uuid },
96d30e48 8191
1f04275e 8192 /* temporary options */
a594cfbf 8193 { "usb", 0, QEMU_OPTION_usb },
6515b203 8194 { "no-acpi", 0, QEMU_OPTION_no_acpi },
d1beab82 8195 { "no-reboot", 0, QEMU_OPTION_no_reboot },
b2f76161 8196 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
9467cd46 8197 { "show-cursor", 0, QEMU_OPTION_show_cursor },
71e3ceb8 8198 { "daemonize", 0, QEMU_OPTION_daemonize },
9ae02555 8199 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
a87295e8 8200#if defined(TARGET_ARM) || defined(TARGET_M68K)
8e71621f
PB		 8201 { "semihosting", 0, QEMU_OPTION_semihosting },
8202#endif
c35734b2 8203 { "name", HAS_ARG, QEMU_OPTION_name },
66508601
BS		 8204#if defined(TARGET_SPARC)
8205 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
2b8f2d41
AZ		 8206#endif
8207#if defined(TARGET_ARM)
8208 { "old-param", 0, QEMU_OPTION_old_param },
66508601 8209#endif
f3dcfada 8210 { "clock", HAS_ARG, QEMU_OPTION_clock },
7e0af5d0 8211 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
26a5f13b 8212 { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
2e70f6ef 8213 { "icount", HAS_ARG, QEMU_OPTION_icount },
cd6f1169 8214 { NULL },
fc01f7e7
FB		 8215};
8216
5905b2e5
FB		 8217/* password input */
8218
2bac6019
AZ		 8219int qemu_key_check(BlockDriverState *bs, const char *name)
8220{
8221 char password[256];
8222 int i;
8223
8224 if (!bdrv_is_encrypted(bs))
8225 return 0;
8226
8227 term_printf("%s is encrypted.\n", name);
8228 for(i = 0; i < 3; i++) {
8229 monitor_readline("Password: ", 1, password, sizeof(password));
8230 if (bdrv_set_key(bs, password) == 0)
8231 return 0;
8232 term_printf("invalid password\n");
8233 }
8234 return -EPERM;
8235}
8236
83ab7950
AL		 8237static BlockDriverState *get_bdrv(int index)
8238{
8239 if (index > nb_drives)
8240 return NULL;
8241 return drives_table[index].bdrv;
8242}
8243
5905b2e5
FB		 8244static void read_passwords(void)
8245{
8246 BlockDriverState *bs;
2bac6019 8247 int i;
5905b2e5 8248
83ab7950
AL		 8249 for(i = 0; i < 6; i++) {
8250 bs = get_bdrv(i);
8251 if (bs)
8252 qemu_key_check(bs, bdrv_get_device_name(bs));
5905b2e5
FB		 8253 }
8254}
8255
1d14ffa9 8256#ifdef HAS_AUDIO
6a36d84e 8257struct soundhw soundhw[] = {
b00052e4 8258#ifdef HAS_AUDIO_CHOICE
4ce7ff6e 8259#if defined(TARGET_I386) || defined(TARGET_MIPS)
fd06c375
FB		 8260 {
8261 "pcspk",
8262 "PC speaker",
8263 0,
8264 1,
8265 { .init_isa = pcspk_audio_init }
8266 },
8267#endif
6a36d84e
FB		 8268 {
8269 "sb16",
8270 "Creative Sound Blaster 16",
8271 0,
8272 1,
8273 { .init_isa = SB16_init }
8274 },
8275
cc53d26d 8276#ifdef CONFIG_CS4231A
8277 {
8278 "cs4231a",
8279 "CS4231A",
8280 0,
8281 1,
8282 { .init_isa = cs4231a_init }
8283 },
8284#endif
8285
1d14ffa9 8286#ifdef CONFIG_ADLIB
6a36d84e
FB		 8287 {
8288 "adlib",
1d14ffa9 8289#ifdef HAS_YMF262
6a36d84e 8290 "Yamaha YMF262 (OPL3)",
1d14ffa9 8291#else
6a36d84e 8292 "Yamaha YM3812 (OPL2)",
1d14ffa9 8293#endif
6a36d84e
FB		 8294 0,
8295 1,
8296 { .init_isa = Adlib_init }
8297 },
1d14ffa9 8298#endif
6a36d84e 8299
1d14ffa9 8300#ifdef CONFIG_GUS
6a36d84e
FB		 8301 {
8302 "gus",
8303 "Gravis Ultrasound GF1",
8304 0,
8305 1,
8306 { .init_isa = GUS_init }
8307 },
1d14ffa9 8308#endif
6a36d84e 8309
e5c9a13e
AZ		 8310#ifdef CONFIG_AC97
8311 {
8312 "ac97",
8313 "Intel 82801AA AC97 Audio",
8314 0,
8315 0,
8316 { .init_pci = ac97_init }
8317 },
8318#endif
8319
6a36d84e
FB		 8320 {
8321 "es1370",
8322 "ENSONIQ AudioPCI ES1370",
8323 0,
8324 0,
8325 { .init_pci = es1370_init }
8326 },
b00052e4 8327#endif
6a36d84e
FB		 8328
8329 { NULL, NULL, 0, 0, { NULL } }
8330};
8331
8332static void select_soundhw (const char *optarg)
8333{
8334 struct soundhw *c;
8335
8336 if (*optarg == '?') {
8337 show_valid_cards:
8338
8339 printf ("Valid sound card names (comma separated):\n");
8340 for (c = soundhw; c->name; ++c) {
8341 printf ("%-11s %s\n", c->name, c->descr);
8342 }
8343 printf ("\n-soundhw all will enable all of the above\n");
1d14ffa9
FB		 8344 exit (*optarg != '?');
8345 }
8346 else {
6a36d84e 8347 size_t l;
1d14ffa9
FB		 8348 const char *p;
8349 char *e;
8350 int bad_card = 0;
8351
6a36d84e
FB		 8352 if (!strcmp (optarg, "all")) {
8353 for (c = soundhw; c->name; ++c) {
8354 c->enabled = 1;
8355 }
8356 return;
8357 }
1d14ffa9 8358
6a36d84e 8359 p = optarg;
1d14ffa9
FB		 8360 while (*p) {
8361 e = strchr (p, ',');
8362 l = !e ? strlen (p) : (size_t) (e - p);
6a36d84e
FB		 8363
8364 for (c = soundhw; c->name; ++c) {
8365 if (!strncmp (c->name, p, l)) {
8366 c->enabled = 1;
1d14ffa9
FB		 8367 break;
8368 }
8369 }
6a36d84e
FB		 8370
8371 if (!c->name) {
1d14ffa9
FB		 8372 if (l > 80) {
8373 fprintf (stderr,
8374 "Unknown sound card name (too big to show)\n");
8375 }
8376 else {
8377 fprintf (stderr, "Unknown sound card name `%.*s'\n",
8378 (int) l, p);
8379 }
8380 bad_card = 1;
8381 }
8382 p += l + (e != NULL);
8383 }
8384
8385 if (bad_card)
8386 goto show_valid_cards;
8387 }
8388}
8389#endif
8390
3893c124 8391static void select_vgahw (const char *p)
8392{
8393 const char *opts;
8394
8395 if (strstart(p, "std", &opts)) {
8396 cirrus_vga_enabled = 0;
8397 vmsvga_enabled = 0;
8398 } else if (strstart(p, "cirrus", &opts)) {
8399 cirrus_vga_enabled = 1;
8400 vmsvga_enabled = 0;
8401 } else if (strstart(p, "vmware", &opts)) {
8402 cirrus_vga_enabled = 0;
8403 vmsvga_enabled = 1;
8404 } else {
8405 invalid_vga:
8406 fprintf(stderr, "Unknown vga type: %s\n", p);
8407 exit(1);
8408 }
cb5a7aa8 8409 while (*opts) {
8410 const char *nextopt;
8411
8412 if (strstart(opts, ",retrace=", &nextopt)) {
8413 opts = nextopt;
8414 if (strstart(opts, "dumb", &nextopt))
8415 vga_retrace_method = VGA_RETRACE_DUMB;
8416 else if (strstart(opts, "precise", &nextopt))
8417 vga_retrace_method = VGA_RETRACE_PRECISE;
8418 else goto invalid_vga;
8419 } else goto invalid_vga;
8420 opts = nextopt;
8421 }
3893c124 8422}
8423
3587d7e6
FB		 8424#ifdef _WIN32
8425static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8426{
8427 exit(STATUS_CONTROL_C_EXIT);
8428 return TRUE;
8429}
8430#endif
8431
8fcb1b90
BS		 8432static int qemu_uuid_parse(const char *str, uint8_t *uuid)
8433{
8434 int ret;
8435
8436 if(strlen(str) != 36)
8437 return -1;
8438
8439 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
8440 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
8441 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
8442
8443 if(ret != 16)
8444 return -1;
8445
8446 return 0;
8447}
8448
7c9d8e07 8449#define MAX_NET_CLIENTS 32
c20709aa 8450
5b08fc10
AL		 8451#ifndef _WIN32
8452
8453static void termsig_handler(int signal)
8454{
8455 qemu_system_shutdown_request();
8456}
8457
6f9e3801 8458static void termsig_setup(void)
5b08fc10
AL		 8459{
8460 struct sigaction act;
8461
8462 memset(&act, 0, sizeof(act));
8463 act.sa_handler = termsig_handler;
8464 sigaction(SIGINT, &act, NULL);
8465 sigaction(SIGHUP, &act, NULL);
8466 sigaction(SIGTERM, &act, NULL);
8467}
8468
8469#endif
8470
0824d6fc
FB		 8471int main(int argc, char **argv)
8472{
67b915a5 8473#ifdef CONFIG_GDBSTUB
cfc3475a
PB		 8474 int use_gdbstub;
8475 const char *gdbstub_port;
67b915a5 8476#endif
28c5af54 8477 uint32_t boot_devices_bitmap = 0;
e4bcb14c 8478 int i;
28c5af54 8479 int snapshot, linux_boot, net_boot;
7f7f9873 8480 const char *initrd_filename;
a20dd508 8481 const char *kernel_filename, *kernel_cmdline;
28c5af54 8482 const char *boot_devices = "";
313aa567 8483 DisplayState *ds = &display_state;
46d4767d 8484 int cyls, heads, secs, translation;
fd5f393a 8485 const char *net_clients[MAX_NET_CLIENTS];
7c9d8e07 8486 int nb_net_clients;
e4bcb14c 8487 int hda_index;
cd6f1169
FB		 8488 int optind;
8489 const char *r, *optarg;
82c643ff 8490 CharDriverState *monitor_hd;
fd5f393a
PB		 8491 const char *monitor_device;
8492 const char *serial_devices[MAX_SERIAL_PORTS];
8d11df9e 8493 int serial_device_index;
fd5f393a 8494 const char *parallel_devices[MAX_PARALLEL_PORTS];
6508fe59 8495 int parallel_device_index;
d63d307f 8496 const char *loadvm = NULL;
cc1daa40 8497 QEMUMachine *machine;
94fc95cd 8498 const char *cpu_model;
fd5f393a 8499 const char *usb_devices[MAX_USB_CMDLINE];
a594cfbf 8500 int usb_devices_index;
71e3ceb8 8501 int fds[2];
26a5f13b 8502 int tb_size;
93815bc2 8503 const char *pid_file = NULL;
833c7174 8504 VLANState *vlan;
0bd48850
FB		 8505
8506 LIST_INIT (&vm_change_state_head);
be995c27
FB		 8507#ifndef _WIN32
8508 {
8509 struct sigaction act;
8510 sigfillset(&act.sa_mask);
8511 act.sa_flags = 0;
8512 act.sa_handler = SIG_IGN;
8513 sigaction(SIGPIPE, &act, NULL);
8514 }
3587d7e6
FB		 8515#else
8516 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
a8e5ac33
FB		 8517 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8518 QEMU to run on a single CPU */
8519 {
8520 HANDLE h;
8521 DWORD mask, smask;
8522 int i;
8523 h = GetCurrentProcess();
8524 if (GetProcessAffinityMask(h, &mask, &smask)) {
8525 for(i = 0; i < 32; i++) {
8526 if (mask & (1 << i))
8527 break;
8528 }
8529 if (i != 32) {
8530 mask = 1 << i;
8531 SetProcessAffinityMask(h, mask);
8532 }
8533 }
8534 }
67b915a5 8535#endif
be995c27 8536
cc1daa40
FB		 8537 register_machines();
8538 machine = first_machine;
94fc95cd 8539 cpu_model = NULL;
fc01f7e7 8540 initrd_filename = NULL;
4fc5d071 8541 ram_size = 0;
313aa567 8542 vga_ram_size = VGA_RAM_SIZE;
67b915a5 8543#ifdef CONFIG_GDBSTUB
b4608c04 8544 use_gdbstub = 0;
c636bb66 8545 gdbstub_port = DEFAULT_GDBSTUB_PORT;
67b915a5 8546#endif
33e3963e 8547 snapshot = 0;
a20dd508 8548 nographic = 0;
4d3b6f6e 8549 curses = 0;
a20dd508
FB		 8550 kernel_filename = NULL;
8551 kernel_cmdline = "";
c4b1fcc0 8552 cyls = heads = secs = 0;
46d4767d 8553 translation = BIOS_ATA_TRANSLATION_AUTO;
c60e08d9 8554 monitor_device = "vc";
c4b1fcc0 8555
c75a823c 8556 serial_devices[0] = "vc:80Cx24C";
8d11df9e 8557 for(i = 1; i < MAX_SERIAL_PORTS; i++)
fd5f393a 8558 serial_devices[i] = NULL;
8d11df9e 8559 serial_device_index = 0;
3b46e624 8560
c75a823c 8561 parallel_devices[0] = "vc:640x480";
6508fe59 8562 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
fd5f393a 8563 parallel_devices[i] = NULL;
6508fe59 8564 parallel_device_index = 0;
3b46e624 8565
a594cfbf 8566 usb_devices_index = 0;
3b46e624 8567
7c9d8e07 8568 nb_net_clients = 0;
e4bcb14c
TS		 8569 nb_drives = 0;
8570 nb_drives_opt = 0;
8571 hda_index = -1;
7c9d8e07
FB		 8572
8573 nb_nics = 0;
3b46e624 8574
26a5f13b
FB		 8575 tb_size = 0;
8576
cd6f1169 8577 optind = 1;
0824d6fc 8578 for(;;) {
cd6f1169 8579 if (optind >= argc)
0824d6fc 8580 break;
cd6f1169
FB		 8581 r = argv[optind];
8582 if (r[0] != '-') {
609497ab 8583 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
cd6f1169
FB		 8584 } else {
8585 const QEMUOption *popt;
8586
8587 optind++;
dff5efc8
PB		 8588 /* Treat --foo the same as -foo. */
8589 if (r[1] == '-')
8590 r++;
cd6f1169
FB		 8591 popt = qemu_options;
8592 for(;;) {
8593 if (!popt->name) {
5fafdf24 8594 fprintf(stderr, "%s: invalid option -- '%s'\n",
cd6f1169
FB		 8595 argv[0], r);
8596 exit(1);
8597 }
8598 if (!strcmp(popt->name, r + 1))
8599 break;
8600 popt++;
8601 }
8602 if (popt->flags & HAS_ARG) {
8603 if (optind >= argc) {
8604 fprintf(stderr, "%s: option '%s' requires an argument\n",
8605 argv[0], r);
8606 exit(1);
8607 }
8608 optarg = argv[optind++];
8609 } else {
8610 optarg = NULL;
8611 }
8612
8613 switch(popt->index) {
cc1daa40
FB		 8614 case QEMU_OPTION_M:
8615 machine = find_machine(optarg);
8616 if (!machine) {
8617 QEMUMachine *m;
8618 printf("Supported machines are:\n");
8619 for(m = first_machine; m != NULL; m = m->next) {
8620 printf("%-10s %s%s\n",
5fafdf24 8621 m->name, m->desc,
cc1daa40
FB		 8622 m == first_machine ? " (default)" : "");
8623 }
15f82208 8624 exit(*optarg != '?');
cc1daa40
FB		 8625 }
8626 break;
94fc95cd
JM		 8627 case QEMU_OPTION_cpu:
8628 /* hw initialization will check this */
15f82208 8629 if (*optarg == '?') {
c732abe2
JM		 8630/* XXX: implement xxx_cpu_list for targets that still miss it */
8631#if defined(cpu_list)
8632 cpu_list(stdout, &fprintf);
94fc95cd 8633#endif
15f82208 8634 exit(0);
94fc95cd
JM		 8635 } else {
8636 cpu_model = optarg;
8637 }
8638 break;
cd6f1169 8639 case QEMU_OPTION_initrd:
fc01f7e7
FB		 8640 initrd_filename = optarg;
8641 break;
cd6f1169 8642 case QEMU_OPTION_hda:
e4bcb14c 8643 if (cyls == 0)
609497ab 8644 hda_index = drive_add(optarg, HD_ALIAS, 0);
e4bcb14c 8645 else
609497ab 8646 hda_index = drive_add(optarg, HD_ALIAS
e4bcb14c 8647 ",cyls=%d,heads=%d,secs=%d%s",
609497ab 8648 0, cyls, heads, secs,
e4bcb14c
TS		 8649 translation == BIOS_ATA_TRANSLATION_LBA ?
8650 ",trans=lba" :
8651 translation == BIOS_ATA_TRANSLATION_NONE ?
8652 ",trans=none" : "");
8653 break;
cd6f1169 8654 case QEMU_OPTION_hdb:
cc1daa40
FB		 8655 case QEMU_OPTION_hdc:
8656 case QEMU_OPTION_hdd:
609497ab 8657 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
fc01f7e7 8658 break;
e4bcb14c 8659 case QEMU_OPTION_drive:
609497ab 8660 drive_add(NULL, "%s", optarg);
e4bcb14c 8661 break;
3e3d5815 8662 case QEMU_OPTION_mtdblock:
609497ab 8663 drive_add(optarg, MTD_ALIAS);
3e3d5815 8664 break;
a1bb27b1 8665 case QEMU_OPTION_sd:
609497ab 8666 drive_add(optarg, SD_ALIAS);
a1bb27b1 8667 break;
86f55663 8668 case QEMU_OPTION_pflash:
609497ab 8669 drive_add(optarg, PFLASH_ALIAS);
86f55663 8670 break;
cd6f1169 8671 case QEMU_OPTION_snapshot:
33e3963e
FB		 8672 snapshot = 1;
8673 break;
cd6f1169 8674 case QEMU_OPTION_hdachs:
330d0414 8675 {
330d0414
FB		 8676 const char *p;
8677 p = optarg;
8678 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 8679 if (cyls < 1 || cyls > 16383)
8680 goto chs_fail;
330d0414
FB		 8681 if (*p != ',')
8682 goto chs_fail;
8683 p++;
8684 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 8685 if (heads < 1 || heads > 16)
8686 goto chs_fail;
330d0414
FB		 8687 if (*p != ',')
8688 goto chs_fail;
8689 p++;
8690 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 8691 if (secs < 1 || secs > 63)
8692 goto chs_fail;
8693 if (*p == ',') {
8694 p++;
8695 if (!strcmp(p, "none"))
8696 translation = BIOS_ATA_TRANSLATION_NONE;
8697 else if (!strcmp(p, "lba"))
8698 translation = BIOS_ATA_TRANSLATION_LBA;
8699 else if (!strcmp(p, "auto"))
8700 translation = BIOS_ATA_TRANSLATION_AUTO;
8701 else
8702 goto chs_fail;
8703 } else if (*p != '\0') {
c4b1fcc0 8704 chs_fail:
46d4767d
FB		 8705 fprintf(stderr, "qemu: invalid physical CHS format\n");
8706 exit(1);
c4b1fcc0 8707 }
e4bcb14c 8708 if (hda_index != -1)
609497ab
AZ		 8709 snprintf(drives_opt[hda_index].opt,
8710 sizeof(drives_opt[hda_index].opt),
8711 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8712 0, cyls, heads, secs,
e4bcb14c
TS		 8713 translation == BIOS_ATA_TRANSLATION_LBA ?
8714 ",trans=lba" :
8715 translation == BIOS_ATA_TRANSLATION_NONE ?
8716 ",trans=none" : "");
330d0414
FB		 8717 }
8718 break;
cd6f1169 8719 case QEMU_OPTION_nographic:
a20dd508
FB		 8720 nographic = 1;
8721 break;
4d3b6f6e
AZ		 8722#ifdef CONFIG_CURSES
8723 case QEMU_OPTION_curses:
8724 curses = 1;
8725 break;
8726#endif
a171fe39
AZ		 8727 case QEMU_OPTION_portrait:
8728 graphic_rotate = 1;
8729 break;
cd6f1169 8730 case QEMU_OPTION_kernel:
a20dd508
FB		 8731 kernel_filename = optarg;
8732 break;
cd6f1169 8733 case QEMU_OPTION_append:
a20dd508 8734 kernel_cmdline = optarg;
313aa567 8735 break;
cd6f1169 8736 case QEMU_OPTION_cdrom:
609497ab 8737 drive_add(optarg, CDROM_ALIAS);
36b486bb 8738 break;
cd6f1169 8739 case QEMU_OPTION_boot:
28c5af54
JM		 8740 boot_devices = optarg;
8741 /* We just do some generic consistency checks */
8742 {
8743 /* Could easily be extended to 64 devices if needed */
60fe76f3 8744 const char *p;
28c5af54
JM		 8745
8746 boot_devices_bitmap = 0;
8747 for (p = boot_devices; *p != '\0'; p++) {
8748 /* Allowed boot devices are:
8749 * a b : floppy disk drives
8750 * c ... f : IDE disk drives
8751 * g ... m : machine implementation dependant drives
8752 * n ... p : network devices
8753 * It's up to each machine implementation to check
8754 * if the given boot devices match the actual hardware
8755 * implementation and firmware features.
8756 */
8757 if (*p < 'a' || *p > 'q') {
8758 fprintf(stderr, "Invalid boot device '%c'\n", *p);
8759 exit(1);
8760 }
8761 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8762 fprintf(stderr,
8763 "Boot device '%c' was given twice\n",*p);
8764 exit(1);
8765 }
8766 boot_devices_bitmap |= 1 << (*p - 'a');
8767 }
36b486bb
FB		 8768 }
8769 break;
cd6f1169 8770 case QEMU_OPTION_fda:
cd6f1169 8771 case QEMU_OPTION_fdb:
609497ab 8772 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
c45886db 8773 break;
52ca8d6a
FB		 8774#ifdef TARGET_I386
8775 case QEMU_OPTION_no_fd_bootchk:
8776 fd_bootchk = 0;
8777 break;
8778#endif
7c9d8e07
FB		 8779 case QEMU_OPTION_net:
8780 if (nb_net_clients >= MAX_NET_CLIENTS) {
8781 fprintf(stderr, "qemu: too many network clients\n");
c4b1fcc0
FB		 8782 exit(1);
8783 }
fd5f393a 8784 net_clients[nb_net_clients] = optarg;
7c9d8e07 8785 nb_net_clients++;
702c651c 8786 break;
c7f74643
FB		 8787#ifdef CONFIG_SLIRP
8788 case QEMU_OPTION_tftp:
c7f74643 8789 tftp_prefix = optarg;
9bf05444 8790 break;
47d5d01a
TS		 8791 case QEMU_OPTION_bootp:
8792 bootp_filename = optarg;
8793 break;
c94c8d64 8794#ifndef _WIN32
9d728e8c
FB		 8795 case QEMU_OPTION_smb:
8796 net_slirp_smb(optarg);
8797 break;
c94c8d64 8798#endif
9bf05444 8799 case QEMU_OPTION_redir:
3b46e624 8800 net_slirp_redir(optarg);
9bf05444 8801 break;
c7f74643 8802#endif
1d14ffa9 8803#ifdef HAS_AUDIO
1d14ffa9
FB		 8804 case QEMU_OPTION_audio_help:
8805 AUD_help ();
8806 exit (0);
8807 break;
8808 case QEMU_OPTION_soundhw:
8809 select_soundhw (optarg);
8810 break;
8811#endif
cd6f1169 8812 case QEMU_OPTION_h:
15f82208 8813 help(0);
cd6f1169 8814 break;
00f82b8a
AJ		 8815 case QEMU_OPTION_m: {
8816 uint64_t value;
8817 char *ptr;
8818
8819 value = strtoul(optarg, &ptr, 10);
8820 switch (*ptr) {
8821 case 0: case 'M': case 'm':
8822 value <<= 20;
8823 break;
8824 case 'G': case 'g':
8825 value <<= 30;
8826 break;
8827 default:
8828 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
cd6f1169
FB		 8829 exit(1);
8830 }
00f82b8a
AJ		 8831
8832 /* On 32-bit hosts, QEMU is limited by virtual address space */
8833 if (value > (2047 << 20)
8834#ifndef USE_KQEMU
8835 && HOST_LONG_BITS == 32
8836#endif
8837 ) {
8838 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8839 exit(1);
8840 }
8841 if (value != (uint64_t)(ram_addr_t)value) {
8842 fprintf(stderr, "qemu: ram size too large\n");
8843 exit(1);
8844 }
8845 ram_size = value;
cd6f1169 8846 break;
00f82b8a 8847 }
cd6f1169
FB		 8848 case QEMU_OPTION_d:
8849 {
8850 int mask;
c7cd6a37 8851 const CPULogItem *item;
3b46e624 8852
cd6f1169
FB		 8853 mask = cpu_str_to_log_mask(optarg);
8854 if (!mask) {
8855 printf("Log items (comma separated):\n");
f193c797
FB		 8856 for(item = cpu_log_items; item->mask != 0; item++) {
8857 printf("%-10s %s\n", item->name, item->help);
8858 }
8859 exit(1);
cd6f1169
FB		 8860 }
8861 cpu_set_log(mask);
f193c797 8862 }
cd6f1169 8863 break;
67b915a5 8864#ifdef CONFIG_GDBSTUB
cd6f1169
FB		 8865 case QEMU_OPTION_s:
8866 use_gdbstub = 1;
8867 break;
8868 case QEMU_OPTION_p:
cfc3475a 8869 gdbstub_port = optarg;
cd6f1169 8870 break;
67b915a5 8871#endif
cd6f1169
FB		 8872 case QEMU_OPTION_L:
8873 bios_dir = optarg;
8874 break;
1192dad8
JM		 8875 case QEMU_OPTION_bios:
8876 bios_name = optarg;
8877 break;
cd6f1169 8878 case QEMU_OPTION_S:
3c07f8e8 8879 autostart = 0;
cd6f1169 8880 break;
3d11d0eb
FB		 8881 case QEMU_OPTION_k:
8882 keyboard_layout = optarg;
8883 break;
ee22c2f7
FB		 8884 case QEMU_OPTION_localtime:
8885 rtc_utc = 0;
8886 break;
3893c124 8887 case QEMU_OPTION_vga:
8888 select_vgahw (optarg);
1bfe856e 8889 break;
e9b137c2
FB		 8890 case QEMU_OPTION_g:
8891 {
8892 const char *p;
8893 int w, h, depth;
8894 p = optarg;
8895 w = strtol(p, (char **)&p, 10);
8896 if (w <= 0) {
8897 graphic_error:
8898 fprintf(stderr, "qemu: invalid resolution or depth\n");
8899 exit(1);
8900 }
8901 if (*p != 'x')
8902 goto graphic_error;
8903 p++;
8904 h = strtol(p, (char **)&p, 10);
8905 if (h <= 0)
8906 goto graphic_error;
8907 if (*p == 'x') {
8908 p++;
8909 depth = strtol(p, (char **)&p, 10);
5fafdf24 8910 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 8911 depth != 24 && depth != 32)
8912 goto graphic_error;
8913 } else if (*p == '\0') {
8914 depth = graphic_depth;
8915 } else {
8916 goto graphic_error;
8917 }
3b46e624 8918
e9b137c2
FB		 8919 graphic_width = w;
8920 graphic_height = h;
8921 graphic_depth = depth;
8922 }
8923 break;
20d8a3ed
TS		 8924 case QEMU_OPTION_echr:
8925 {
8926 char *r;
8927 term_escape_char = strtol(optarg, &r, 0);
8928 if (r == optarg)
8929 printf("Bad argument to echr\n");
8930 break;
8931 }
82c643ff 8932 case QEMU_OPTION_monitor:
fd5f393a 8933 monitor_device = optarg;
82c643ff
FB		 8934 break;
8935 case QEMU_OPTION_serial:
8d11df9e
FB		 8936 if (serial_device_index >= MAX_SERIAL_PORTS) {
8937 fprintf(stderr, "qemu: too many serial ports\n");
8938 exit(1);
8939 }
fd5f393a 8940 serial_devices[serial_device_index] = optarg;
8d11df9e 8941 serial_device_index++;
82c643ff 8942 break;
6508fe59
FB		 8943 case QEMU_OPTION_parallel:
8944 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8945 fprintf(stderr, "qemu: too many parallel ports\n");
8946 exit(1);
8947 }
fd5f393a 8948 parallel_devices[parallel_device_index] = optarg;
6508fe59
FB		 8949 parallel_device_index++;
8950 break;
d63d307f
FB		 8951 case QEMU_OPTION_loadvm:
8952 loadvm = optarg;
8953 break;
8954 case QEMU_OPTION_full_screen:
8955 full_screen = 1;
8956 break;
667accab 8957#ifdef CONFIG_SDL
43523e93
TS		 8958 case QEMU_OPTION_no_frame:
8959 no_frame = 1;
8960 break;
3780e197
TS		 8961 case QEMU_OPTION_alt_grab:
8962 alt_grab = 1;
8963 break;
667accab
TS		 8964 case QEMU_OPTION_no_quit:
8965 no_quit = 1;
8966 break;
8967#endif
f7cce898 8968 case QEMU_OPTION_pidfile:
93815bc2 8969 pid_file = optarg;
f7cce898 8970 break;
a09db21f
FB		 8971#ifdef TARGET_I386
8972 case QEMU_OPTION_win2k_hack:
8973 win2k_install_hack = 1;
8974 break;
8975#endif
d993e026
FB		 8976#ifdef USE_KQEMU
8977 case QEMU_OPTION_no_kqemu:
8978 kqemu_allowed = 0;
8979 break;
89bfc105
FB		 8980 case QEMU_OPTION_kernel_kqemu:
8981 kqemu_allowed = 2;
8982 break;
d993e026 8983#endif
bb36d470
FB		 8984 case QEMU_OPTION_usb:
8985 usb_enabled = 1;
8986 break;
a594cfbf
FB		 8987 case QEMU_OPTION_usbdevice:
8988 usb_enabled = 1;
0d92ed30 8989 if (usb_devices_index >= MAX_USB_CMDLINE) {
a594cfbf
FB		 8990 fprintf(stderr, "Too many USB devices\n");
8991 exit(1);
8992 }
fd5f393a 8993 usb_devices[usb_devices_index] = optarg;
a594cfbf
FB		 8994 usb_devices_index++;
8995 break;
6a00d601
FB		 8996 case QEMU_OPTION_smp:
8997 smp_cpus = atoi(optarg);
ba3c64fb 8998 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
6a00d601
FB		 8999 fprintf(stderr, "Invalid number of CPUs\n");
9000 exit(1);
9001 }
9002 break;
24236869 9003 case QEMU_OPTION_vnc:
73fc9742 9004 vnc_display = optarg;
24236869 9005 break;
6515b203
FB		 9006 case QEMU_OPTION_no_acpi:
9007 acpi_enabled = 0;
9008 break;
d1beab82
FB		 9009 case QEMU_OPTION_no_reboot:
9010 no_reboot = 1;
9011 break;
b2f76161
AJ		 9012 case QEMU_OPTION_no_shutdown:
9013 no_shutdown = 1;
9014 break;
9467cd46
AZ		 9015 case QEMU_OPTION_show_cursor:
9016 cursor_hide = 0;
9017 break;
8fcb1b90
BS		 9018 case QEMU_OPTION_uuid:
9019 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
9020 fprintf(stderr, "Fail to parse UUID string."
9021 " Wrong format.\n");
9022 exit(1);
9023 }
9024 break;
71e3ceb8
TS		 9025 case QEMU_OPTION_daemonize:
9026 daemonize = 1;
9027 break;
9ae02555
TS		 9028 case QEMU_OPTION_option_rom:
9029 if (nb_option_roms >= MAX_OPTION_ROMS) {
9030 fprintf(stderr, "Too many option ROMs\n");
9031 exit(1);
9032 }
9033 option_rom[nb_option_roms] = optarg;
9034 nb_option_roms++;
9035 break;
8e71621f
PB		 9036 case QEMU_OPTION_semihosting:
9037 semihosting_enabled = 1;
9038 break;
c35734b2
TS		 9039 case QEMU_OPTION_name:
9040 qemu_name = optarg;
9041 break;
66508601
BS		 9042#ifdef TARGET_SPARC
9043 case QEMU_OPTION_prom_env:
9044 if (nb_prom_envs >= MAX_PROM_ENVS) {
9045 fprintf(stderr, "Too many prom variables\n");
9046 exit(1);
9047 }
9048 prom_envs[nb_prom_envs] = optarg;
9049 nb_prom_envs++;
9050 break;
2b8f2d41
AZ		 9051#endif
9052#ifdef TARGET_ARM
9053 case QEMU_OPTION_old_param:
9054 old_param = 1;
05ebd537 9055 break;
66508601 9056#endif
f3dcfada
TS		 9057 case QEMU_OPTION_clock:
9058 configure_alarms(optarg);
9059 break;
7e0af5d0
FB		 9060 case QEMU_OPTION_startdate:
9061 {
9062 struct tm tm;
f6503059 9063 time_t rtc_start_date;
7e0af5d0 9064 if (!strcmp(optarg, "now")) {
f6503059 9065 rtc_date_offset = -1;
7e0af5d0
FB		 9066 } else {
9067 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
9068 &tm.tm_year,
9069 &tm.tm_mon,
9070 &tm.tm_mday,
9071 &tm.tm_hour,
9072 &tm.tm_min,
9073 &tm.tm_sec) == 6) {
9074 /* OK */
9075 } else if (sscanf(optarg, "%d-%d-%d",
9076 &tm.tm_year,
9077 &tm.tm_mon,
9078 &tm.tm_mday) == 3) {
9079 tm.tm_hour = 0;
9080 tm.tm_min = 0;
9081 tm.tm_sec = 0;
9082 } else {
9083 goto date_fail;
9084 }
9085 tm.tm_year -= 1900;
9086 tm.tm_mon--;
3c6b2088 9087 rtc_start_date = mktimegm(&tm);
7e0af5d0
FB		 9088 if (rtc_start_date == -1) {
9089 date_fail:
9090 fprintf(stderr, "Invalid date format. Valid format are:\n"
9091 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9092 exit(1);
9093 }
f6503059 9094 rtc_date_offset = time(NULL) - rtc_start_date;
7e0af5d0
FB		 9095 }
9096 }
9097 break;
26a5f13b
FB		 9098 case QEMU_OPTION_tb_size:
9099 tb_size = strtol(optarg, NULL, 0);
9100 if (tb_size < 0)
9101 tb_size = 0;
9102 break;
2e70f6ef
PB		 9103 case QEMU_OPTION_icount:
9104 use_icount = 1;
9105 if (strcmp(optarg, "auto") == 0) {
9106 icount_time_shift = -1;
9107 } else {
9108 icount_time_shift = strtol(optarg, NULL, 0);
9109 }
9110 break;
cd6f1169 9111 }
0824d6fc
FB		 9112 }
9113 }
330d0414 9114
bc0129d9
AL		 9115 if (nographic) {
9116 if (serial_device_index == 0)
9117 serial_devices[0] = "stdio";
9118 if (parallel_device_index == 0)
9119 parallel_devices[0] = "null";
9120 if (strncmp(monitor_device, "vc", 2) == 0)
9121 monitor_device = "stdio";
9122 }
9123
71e3ceb8 9124#ifndef _WIN32
71e3ceb8
TS		 9125 if (daemonize) {
9126 pid_t pid;
9127
9128 if (pipe(fds) == -1)
9129 exit(1);
9130
9131 pid = fork();
9132 if (pid > 0) {
9133 uint8_t status;
9134 ssize_t len;
9135
9136 close(fds[1]);
9137
9138 again:
93815bc2
TS		 9139 len = read(fds[0], &status, 1);
9140 if (len == -1 && (errno == EINTR))
9141 goto again;
9142
9143 if (len != 1)
9144 exit(1);
9145 else if (status == 1) {
9146 fprintf(stderr, "Could not acquire pidfile\n");
9147 exit(1);
9148 } else
9149 exit(0);
71e3ceb8 9150 } else if (pid < 0)
93815bc2 9151 exit(1);
71e3ceb8
TS		 9152
9153 setsid();
9154
9155 pid = fork();
9156 if (pid > 0)
9157 exit(0);
9158 else if (pid < 0)
9159 exit(1);
9160
9161 umask(027);
71e3ceb8
TS		 9162
9163 signal(SIGTSTP, SIG_IGN);
9164 signal(SIGTTOU, SIG_IGN);
9165 signal(SIGTTIN, SIG_IGN);
9166 }
9167#endif
9168
aa26bb2d 9169 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
93815bc2
TS		 9170 if (daemonize) {
9171 uint8_t status = 1;
9172 write(fds[1], &status, 1);
9173 } else
9174 fprintf(stderr, "Could not acquire pid file\n");
9175 exit(1);
9176 }
9177
ff3fbb30
FB		 9178#ifdef USE_KQEMU
9179 if (smp_cpus > 1)
9180 kqemu_allowed = 0;
9181#endif
a20dd508 9182 linux_boot = (kernel_filename != NULL);
7317b8ca 9183 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
6c41b272 9184
28c5af54 9185 if (!linux_boot && net_boot == 0 &&
f88e4b91 9186 !machine->nodisk_ok && nb_drives_opt == 0)
15f82208 9187 help(1);
0824d6fc 9188
f8d39c01
TS		 9189 if (!linux_boot && *kernel_cmdline != '\0') {
9190 fprintf(stderr, "-append only allowed with -kernel option\n");
9191 exit(1);
9192 }
9193
9194 if (!linux_boot && initrd_filename != NULL) {
9195 fprintf(stderr, "-initrd only allowed with -kernel option\n");
9196 exit(1);
9197 }
9198
96d30e48 9199 /* boot to floppy or the default cd if no hard disk defined yet */
28c5af54 9200 if (!boot_devices[0]) {
e4bcb14c 9201 boot_devices = "cad";
96d30e48 9202 }
b118d61e 9203 setvbuf(stdout, NULL, _IOLBF, 0);
3b46e624 9204
634fce96
PB		 9205 init_timers();
9206 init_timer_alarm();
2e70f6ef
PB		 9207 if (use_icount && icount_time_shift < 0) {
9208 use_icount = 2;
9209 /* 125MIPS seems a reasonable initial guess at the guest speed.
9210 It will be corrected fairly quickly anyway. */
9211 icount_time_shift = 3;
9212 init_icount_adjust();
9213 }
634fce96 9214
fd1dff4b
FB		 9215#ifdef _WIN32
9216 socket_init();
9217#endif
9218
7c9d8e07
FB		 9219 /* init network clients */
9220 if (nb_net_clients == 0) {
9221 /* if no clients, we use a default config */
f441b28b
AL		 9222 net_clients[nb_net_clients++] = "nic";
9223#ifdef CONFIG_SLIRP
9224 net_clients[nb_net_clients++] = "user";
9225#endif
c20709aa
FB		 9226 }
9227
7c9d8e07 9228 for(i = 0;i < nb_net_clients; i++) {
9ad97e65 9229 if (net_client_parse(net_clients[i]) < 0)
7c9d8e07 9230 exit(1);
702c651c 9231 }
833c7174
BS		 9232 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9233 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
9234 continue;
9ad97e65
AZ		 9235 if (vlan->nb_guest_devs == 0)
9236 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
833c7174
BS		 9237 if (vlan->nb_host_devs == 0)
9238 fprintf(stderr,
9239 "Warning: vlan %d is not connected to host network\n",
9240 vlan->id);
9241 }
f1510b2c 9242
eec85c2a 9243#ifdef TARGET_I386
ed494d87 9244 /* XXX: this should be moved in the PC machine instantiation code */
28c5af54
JM		 9245 if (net_boot != 0) {
9246 int netroms = 0;
9247 for (i = 0; i < nb_nics && i < 4; i++) {
eec85c2a
TS		 9248 const char *model = nd_table[i].model;
9249 char buf[1024];
28c5af54
JM		 9250 if (net_boot & (1 << i)) {
9251 if (model == NULL)
9252 model = "ne2k_pci";
9253 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
9254 if (get_image_size(buf) > 0) {
9255 if (nb_option_roms >= MAX_OPTION_ROMS) {
9256 fprintf(stderr, "Too many option ROMs\n");
9257 exit(1);
9258 }
9259 option_rom[nb_option_roms] = strdup(buf);
9260 nb_option_roms++;
9261 netroms++;
9262 }
9263 }
eec85c2a 9264 }
28c5af54 9265 if (netroms == 0) {
eec85c2a
TS		 9266 fprintf(stderr, "No valid PXE rom found for network device\n");
9267 exit(1);
9268 }
eec85c2a
TS		 9269 }
9270#endif
9271
0824d6fc 9272 /* init the memory */
7fb4fdcf
AZ		 9273 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
9274
9275 if (machine->ram_require & RAMSIZE_FIXED) {
9276 if (ram_size > 0) {
9277 if (ram_size < phys_ram_size) {
cd940061
AJ		 9278 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
9279 machine->name, (unsigned long long) phys_ram_size);
7fb4fdcf
AZ		 9280 exit(-1);
9281 }
9282
9283 phys_ram_size = ram_size;
9284 } else
9285 ram_size = phys_ram_size;
9286 } else {
4fc5d071 9287 if (ram_size == 0)
7fb4fdcf
AZ		 9288 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9289
9290 phys_ram_size += ram_size;
9291 }
9ae02555 9292
d993e026 9293 phys_ram_base = qemu_vmalloc(phys_ram_size);
7f7f9873
FB		 9294 if (!phys_ram_base) {
9295 fprintf(stderr, "Could not allocate physical memory\n");
0824d6fc
FB		 9296 exit(1);
9297 }
9298
26a5f13b
FB		 9299 /* init the dynamic translator */
9300 cpu_exec_init_all(tb_size * 1024 * 1024);
9301
5905b2e5 9302 bdrv_init();
c4b1fcc0 9303
e4bcb14c 9304 /* we always create the cdrom drive, even if no disk is there */
c4b1fcc0 9305
e4bcb14c 9306 if (nb_drives_opt < MAX_DRIVES)
609497ab 9307 drive_add(NULL, CDROM_ALIAS);
c4b1fcc0 9308
9d413d1d 9309 /* we always create at least one floppy */
33e3963e 9310
e4bcb14c 9311 if (nb_drives_opt < MAX_DRIVES)
609497ab 9312 drive_add(NULL, FD_ALIAS, 0);
86f55663 9313
9d413d1d
AZ		 9314 /* we always create one sd slot, even if no card is in it */
9315
9316 if (nb_drives_opt < MAX_DRIVES)
609497ab 9317 drive_add(NULL, SD_ALIAS);
9d413d1d 9318
e4bcb14c
TS		 9319 /* open the virtual block devices */
9320
9321 for(i = 0; i < nb_drives_opt; i++)
609497ab 9322 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
e4bcb14c 9323 exit(1);
3e3d5815 9324
c88676f8
FB		 9325 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
9326 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8a7ddc38 9327
313aa567 9328 /* terminal init */
740733bb 9329 memset(&display_state, 0, sizeof(display_state));
a20dd508 9330 if (nographic) {
4d3b6f6e
AZ		 9331 if (curses) {
9332 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
9333 exit(1);
9334 }
2ff89790
TS		 9335 /* nearly nothing to do */
9336 dumb_display_init(ds);
73fc9742 9337 } else if (vnc_display != NULL) {
71cab5ca
TS		 9338 vnc_display_init(ds);
9339 if (vnc_display_open(ds, vnc_display) < 0)
9340 exit(1);
4d3b6f6e
AZ		 9341 } else
9342#if defined(CONFIG_CURSES)
9343 if (curses) {
9344 curses_display_init(ds, full_screen);
9345 } else
9346#endif
9347 {
5b0753e0 9348#if defined(CONFIG_SDL)
43523e93 9349 sdl_display_init(ds, full_screen, no_frame);
5b0753e0
FB		 9350#elif defined(CONFIG_COCOA)
9351 cocoa_display_init(ds, full_screen);
67276f53
PB		 9352#else
9353 dumb_display_init(ds);
313aa567
FB		 9354#endif
9355 }
0824d6fc 9356
5b08fc10
AL		 9357#ifndef _WIN32
9358 /* must be after terminal init, SDL library changes signal handlers */
9359 termsig_setup();
9360#endif
9361
20d8a3ed
TS		 9362 /* Maintain compatibility with multiple stdio monitors */
9363 if (!strcmp(monitor_device,"stdio")) {
9364 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
fd5f393a
PB		 9365 const char *devname = serial_devices[i];
9366 if (devname && !strcmp(devname,"mon:stdio")) {
9367 monitor_device = NULL;
20d8a3ed 9368 break;
fd5f393a
PB		 9369 } else if (devname && !strcmp(devname,"stdio")) {
9370 monitor_device = NULL;
9371 serial_devices[i] = "mon:stdio";
20d8a3ed
TS		 9372 break;
9373 }
9374 }
9375 }
fd5f393a 9376 if (monitor_device) {
20d8a3ed
TS		 9377 monitor_hd = qemu_chr_open(monitor_device);
9378 if (!monitor_hd) {
9379 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9380 exit(1);
9381 }
9382 monitor_init(monitor_hd, !nographic);
82c643ff 9383 }
82c643ff 9384
8d11df9e 9385 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
c03b0f0f 9386 const char *devname = serial_devices[i];
fd5f393a 9387 if (devname && strcmp(devname, "none")) {
c03b0f0f 9388 serial_hds[i] = qemu_chr_open(devname);
8d11df9e 9389 if (!serial_hds[i]) {
5fafdf24 9390 fprintf(stderr, "qemu: could not open serial device '%s'\n",
c03b0f0f 9391 devname);
8d11df9e
FB		 9392 exit(1);
9393 }
af3a9031 9394 if (strstart(devname, "vc", 0))
7ba1260a 9395 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8d11df9e 9396 }
82c643ff 9397 }
82c643ff 9398
6508fe59 9399 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
c03b0f0f 9400 const char *devname = parallel_devices[i];
fd5f393a 9401 if (devname && strcmp(devname, "none")) {
c03b0f0f 9402 parallel_hds[i] = qemu_chr_open(devname);
6508fe59 9403 if (!parallel_hds[i]) {
5fafdf24 9404 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
c03b0f0f 9405 devname);
6508fe59
FB		 9406 exit(1);
9407 }
af3a9031 9408 if (strstart(devname, "vc", 0))
7ba1260a 9409 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6508fe59
FB		 9410 }
9411 }
9412
b881c2c6 9413 machine->init(ram_size, vga_ram_size, boot_devices, ds,
94fc95cd 9414 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
73332e5c 9415
0d92ed30
PB		 9416 /* init USB devices */
9417 if (usb_enabled) {
9418 for(i = 0; i < usb_devices_index; i++) {
9419 if (usb_device_add(usb_devices[i]) < 0) {
9420 fprintf(stderr, "Warning: could not add USB device %s\n",
9421 usb_devices[i]);
9422 }
9423 }
9424 }
9425
740733bb
TS		 9426 if (display_state.dpy_refresh) {
9427 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9428 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9429 }
7f7f9873 9430
67b915a5 9431#ifdef CONFIG_GDBSTUB
b4608c04 9432 if (use_gdbstub) {
c636bb66
FB		 9433 /* XXX: use standard host:port notation and modify options
9434 accordingly. */
cfc3475a
PB		 9435 if (gdbserver_start(gdbstub_port) < 0) {
9436 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
c636bb66 9437 gdbstub_port);
8a7ddc38 9438 exit(1);
8a7ddc38 9439 }
45669e00 9440 }
67b915a5 9441#endif
45669e00 9442
d63d307f 9443 if (loadvm)
faea38e7 9444 do_loadvm(loadvm);
d63d307f 9445
67b915a5 9446 {
5905b2e5 9447 /* XXX: simplify init */
83ab7950 9448 read_passwords();
3c07f8e8 9449 if (autostart) {
5905b2e5
FB		 9450 vm_start();
9451 }
0824d6fc 9452 }
ffd843bc 9453
71e3ceb8
TS		 9454 if (daemonize) {
9455 uint8_t status = 0;
9456 ssize_t len;
9457 int fd;
9458
9459 again1:
9460 len = write(fds[1], &status, 1);
9461 if (len == -1 && (errno == EINTR))
9462 goto again1;
9463
9464 if (len != 1)
9465 exit(1);
9466
bd54b863 9467 chdir("/");
aeb30be6 9468 TFR(fd = open("/dev/null", O_RDWR));
71e3ceb8
TS		 9469 if (fd == -1)
9470 exit(1);
9471
9472 dup2(fd, 0);
9473 dup2(fd, 1);
9474 dup2(fd, 2);
9475
9476 close(fd);
9477 }
9478
8a7ddc38 9479 main_loop();
40c3bac3 9480 quit_timers();
b46a8906 9481
7d294b61 9482#if !defined(_WIN32)
b46a8906
TS		 9483 /* close network clients */
9484 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9485 VLANClientState *vc;
9486
7d294b61 9487 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
b46a8906
TS		 9488 if (vc->fd_read == tap_receive) {
9489 char ifname[64];
9490 TAPState *s = vc->opaque;
9491
9492 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9493 s->down_script[0])
9494 launch_script(s->down_script, ifname, s->fd);
9495 }
8a16d273
TS		 9496#if defined(CONFIG_VDE)
9497 if (vc->fd_read == vde_from_qemu) {
9498 VDEState *s = vc->opaque;
9499 vde_close(s->vde);
9500 }
9501#endif
4fddf62a 9502 }
7d294b61
TS		 9503 }
9504#endif
0824d6fc
FB		 9505 return 0;
9506}
QEMU mirror