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