]> 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
Remove unused functions
[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
6229static int fd_put_buffer(void *opaque, const uint8_t *buf,
6230 int64_t pos, int size)
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);
6246
6247 return len;
6248}
6249
6250static int fd_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6251{
6252 QEMUFileFD *s = opaque;
6253 ssize_t len;
6254
6255 do {
6256 len = read(s->fd, buf, size);
6257 } while (len == -1 && errno == EINTR);
6258
6259 if (len == -1)
6260 len = -errno;
6261
6262 return len;
6263}
6264
6265static int fd_close(void *opaque)
6266{
6267 QEMUFileFD *s = opaque;
6268 qemu_free(s);
6269 return 0;
6270}
6271
6272QEMUFile *qemu_fopen_fd(int fd)
6273{
6274 QEMUFileFD *s = qemu_mallocz(sizeof(QEMUFileFD));
6275
6276 if (s == NULL)
6277 return NULL;
6278
6279 s->fd = fd;
6280 s->file = qemu_fopen_ops(s, fd_put_buffer, fd_get_buffer, fd_close, NULL);
6281 return s->file;
6282}
6283
6284typedef struct QEMUFileStdio
6285{
6286 FILE *outfile;
6287} QEMUFileStdio;
6288
6289static void file_put_buffer(void *opaque, const uint8_t *buf,
6290 int64_t pos, int size)
6291{
6292 QEMUFileStdio *s = opaque;
6293 fseek(s->outfile, pos, SEEK_SET);
6294 fwrite(buf, 1, size, s->outfile);
6295}
6296
6297static int file_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6298{
6299 QEMUFileStdio *s = opaque;
6300 fseek(s->outfile, pos, SEEK_SET);
6301 return fread(buf, 1, size, s->outfile);
6302}
6303
6304static int file_close(void *opaque)
6305{
6306 QEMUFileStdio *s = opaque;
6307 fclose(s->outfile);
6308 qemu_free(s);
6309 return 0;
6310}
6311
faea38e7
FB		 6312QEMUFile *qemu_fopen(const char *filename, const char *mode)
6313{
5dafc53f 6314 QEMUFileStdio *s;
faea38e7 6315
5dafc53f
AL		 6316 s = qemu_mallocz(sizeof(QEMUFileStdio));
6317 if (!s)
faea38e7 6318 return NULL;
5dafc53f
AL		 6319
6320 s->outfile = fopen(filename, mode);
6321 if (!s->outfile)
faea38e7 6322 goto fail;
5dafc53f
AL		 6323
6324 if (!strcmp(mode, "wb"))
6325 return qemu_fopen_ops(s, file_put_buffer, NULL, file_close, NULL);
6326 else if (!strcmp(mode, "rb"))
6327 return qemu_fopen_ops(s, NULL, file_get_buffer, file_close, NULL);
6328
6329fail:
6330 if (s->outfile)
6331 fclose(s->outfile);
6332 qemu_free(s);
faea38e7
FB		 6333 return NULL;
6334}
6335
5dafc53f
AL		 6336typedef struct QEMUFileBdrv
6337{
6338 BlockDriverState *bs;
6339 int64_t base_offset;
6340} QEMUFileBdrv;
6341
6342static void bdrv_put_buffer(void *opaque, const uint8_t *buf,
6343 int64_t pos, int size)
6344{
6345 QEMUFileBdrv *s = opaque;
6346 bdrv_pwrite(s->bs, s->base_offset + pos, buf, size);
6347}
6348
6349static int bdrv_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
6350{
6351 QEMUFileBdrv *s = opaque;
6352 return bdrv_pread(s->bs, s->base_offset + pos, buf, size);
6353}
6354
6355static int bdrv_fclose(void *opaque)
6356{
6357 QEMUFileBdrv *s = opaque;
6358 qemu_free(s);
6359 return 0;
6360}
6361
674bb261 6362static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5dafc53f
AL		 6363{
6364 QEMUFileBdrv *s;
6365
6366 s = qemu_mallocz(sizeof(QEMUFileBdrv));
6367 if (!s)
6368 return NULL;
6369
6370 s->bs = bs;
6371 s->base_offset = offset;
6372
6373 if (is_writable)
6374 return qemu_fopen_ops(s, bdrv_put_buffer, NULL, bdrv_fclose, NULL);
6375
6376 return qemu_fopen_ops(s, NULL, bdrv_get_buffer, bdrv_fclose, NULL);
6377}
6378
6379QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
6380 QEMUFileGetBufferFunc *get_buffer,
6381 QEMUFileCloseFunc *close,
6382 QEMUFileRateLimit *rate_limit)
faea38e7
FB		 6383{
6384 QEMUFile *f;
6385
6386 f = qemu_mallocz(sizeof(QEMUFile));
6387 if (!f)
6388 return NULL;
5dafc53f
AL		 6389
6390 f->opaque = opaque;
6391 f->put_buffer = put_buffer;
6392 f->get_buffer = get_buffer;
6393 f->close = close;
6394 f->rate_limit = rate_limit;
6395
faea38e7
FB		 6396 return f;
6397}
6398
6399void qemu_fflush(QEMUFile *f)
6400{
5dafc53f 6401 if (!f->put_buffer)
faea38e7 6402 return;
5dafc53f 6403
faea38e7 6404 if (f->buf_index > 0) {
5dafc53f 6405 f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
faea38e7
FB		 6406 f->buf_offset += f->buf_index;
6407 f->buf_index = 0;
6408 }
6409}
6410
6411static void qemu_fill_buffer(QEMUFile *f)
6412{
6413 int len;
6414
5dafc53f 6415 if (!f->get_buffer)
faea38e7 6416 return;
5dafc53f
AL		 6417
6418 len = f->get_buffer(f->opaque, f->buf, f->buf_offset, IO_BUF_SIZE);
6419 if (len < 0)
6420 len = 0;
6421
faea38e7
FB		 6422 f->buf_index = 0;
6423 f->buf_size = len;
6424 f->buf_offset += len;
6425}
6426
5dafc53f 6427int qemu_fclose(QEMUFile *f)
faea38e7 6428{
5dafc53f
AL		 6429 int ret = 0;
6430 qemu_fflush(f);
6431 if (f->close)
6432 ret = f->close(f->opaque);
faea38e7 6433 qemu_free(f);
5dafc53f
AL		 6434 return ret;
6435}
6436
6437void qemu_file_put_notify(QEMUFile *f)
6438{
6439 f->put_buffer(f->opaque, NULL, 0, 0);
faea38e7
FB		 6440}
6441
2ca83a8d 6442void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
b4608c04 6443{
2ca83a8d 6444 int l;
faea38e7
FB		 6445 while (size > 0) {
6446 l = IO_BUF_SIZE - f->buf_index;
6447 if (l > size)
6448 l = size;
6449 memcpy(f->buf + f->buf_index, buf, l);
6450 f->buf_index += l;
6451 buf += l;
6452 size -= l;
6453 if (f->buf_index >= IO_BUF_SIZE)
6454 qemu_fflush(f);
6455 }
b4608c04
FB		 6456}
6457
2ca83a8d 6458void qemu_put_byte(QEMUFile *f, int v)
b4608c04 6459{
faea38e7
FB		 6460 f->buf[f->buf_index++] = v;
6461 if (f->buf_index >= IO_BUF_SIZE)
6462 qemu_fflush(f);
6463}
6464
2ca83a8d 6465int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
faea38e7 6466{
2ca83a8d 6467 int size, l;
faea38e7
FB		 6468
6469 size = size1;
6470 while (size > 0) {
6471 l = f->buf_size - f->buf_index;
6472 if (l == 0) {
6473 qemu_fill_buffer(f);
6474 l = f->buf_size - f->buf_index;
6475 if (l == 0)
6476 break;
6477 }
6478 if (l > size)
6479 l = size;
6480 memcpy(buf, f->buf + f->buf_index, l);
6481 f->buf_index += l;
6482 buf += l;
6483 size -= l;
6484 }
6485 return size1 - size;
6486}
6487
2ca83a8d 6488int qemu_get_byte(QEMUFile *f)
faea38e7
FB		 6489{
6490 if (f->buf_index >= f->buf_size) {
6491 qemu_fill_buffer(f);
6492 if (f->buf_index >= f->buf_size)
6493 return 0;
6494 }
6495 return f->buf[f->buf_index++];
6496}
6497
6498int64_t qemu_ftell(QEMUFile *f)
6499{
6500 return f->buf_offset - f->buf_size + f->buf_index;
6501}
6502
6503int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
6504{
6505 if (whence == SEEK_SET) {
6506 /* nothing to do */
6507 } else if (whence == SEEK_CUR) {
6508 pos += qemu_ftell(f);
6509 } else {
6510 /* SEEK_END not supported */
6511 return -1;
6512 }
5dafc53f 6513 if (f->put_buffer) {
faea38e7
FB		 6514 qemu_fflush(f);
6515 f->buf_offset = pos;
6516 } else {
6517 f->buf_offset = pos;
6518 f->buf_index = 0;
6519 f->buf_size = 0;
6520 }
6521 return pos;
8a7ddc38
FB		 6522}
6523
5dafc53f
AL		 6524int qemu_file_rate_limit(QEMUFile *f)
6525{
6526 if (f->rate_limit)
6527 return f->rate_limit(f->opaque);
6528
6529 return 0;
6530}
6531
2ca83a8d 6532void qemu_put_be16(QEMUFile *f, unsigned int v)
8a7ddc38
FB		 6533{
6534 qemu_put_byte(f, v >> 8);
6535 qemu_put_byte(f, v);
6536}
6537
2ca83a8d 6538void qemu_put_be32(QEMUFile *f, unsigned int v)
8a7ddc38
FB		 6539{
6540 qemu_put_byte(f, v >> 24);
6541 qemu_put_byte(f, v >> 16);
6542 qemu_put_byte(f, v >> 8);
6543 qemu_put_byte(f, v);
6544}
6545
6546void qemu_put_be64(QEMUFile *f, uint64_t v)
6547{
6548 qemu_put_be32(f, v >> 32);
6549 qemu_put_be32(f, v);
6550}
6551
2ca83a8d 6552unsigned int qemu_get_be16(QEMUFile *f)
8a7ddc38 6553{
2ca83a8d 6554 unsigned int v;
8a7ddc38
FB		 6555 v = qemu_get_byte(f) << 8;
6556 v |= qemu_get_byte(f);
6557 return v;
6558}
6559
2ca83a8d 6560unsigned int qemu_get_be32(QEMUFile *f)
8a7ddc38 6561{
2ca83a8d 6562 unsigned int v;
8a7ddc38
FB		 6563 v = qemu_get_byte(f) << 24;
6564 v |= qemu_get_byte(f) << 16;
6565 v |= qemu_get_byte(f) << 8;
6566 v |= qemu_get_byte(f);
6567 return v;
6568}
6569
6570uint64_t qemu_get_be64(QEMUFile *f)
6571{
6572 uint64_t v;
6573 v = (uint64_t)qemu_get_be32(f) << 32;
6574 v |= qemu_get_be32(f);
6575 return v;
6576}
6577
8a7ddc38
FB		 6578typedef struct SaveStateEntry {
6579 char idstr[256];
6580 int instance_id;
6581 int version_id;
6582 SaveStateHandler *save_state;
6583 LoadStateHandler *load_state;
6584 void *opaque;
6585 struct SaveStateEntry *next;
6586} SaveStateEntry;
b4608c04 6587
8a7ddc38
FB		 6588static SaveStateEntry *first_se;
6589
18be5187 6590/* TODO: Individual devices generally have very little idea about the rest
18fdb1c5
TS		 6591 of the system, so instance_id should be removed/replaced.
6592 Meanwhile pass -1 as instance_id if you do not already have a clearly
6593 distinguishing id for all instances of your device class. */
5fafdf24
TS		 6594int register_savevm(const char *idstr,
6595 int instance_id,
8a7ddc38
FB		 6596 int version_id,
6597 SaveStateHandler *save_state,
6598 LoadStateHandler *load_state,
6599 void *opaque)
6600{
6601 SaveStateEntry *se, **pse;
6602
6603 se = qemu_malloc(sizeof(SaveStateEntry));
6604 if (!se)
6605 return -1;
6606 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
18be5187 6607 se->instance_id = (instance_id == -1) ? 0 : instance_id;
8a7ddc38
FB		 6608 se->version_id = version_id;
6609 se->save_state = save_state;
6610 se->load_state = load_state;
6611 se->opaque = opaque;
6612 se->next = NULL;
6613
6614 /* add at the end of list */
6615 pse = &first_se;
18be5187
PB		 6616 while (*pse != NULL) {
6617 if (instance_id == -1
6618 && strcmp(se->idstr, (*pse)->idstr) == 0
6619 && se->instance_id <= (*pse)->instance_id)
6620 se->instance_id = (*pse)->instance_id + 1;
8a7ddc38 6621 pse = &(*pse)->next;
18be5187 6622 }
8a7ddc38
FB		 6623 *pse = se;
6624 return 0;
6625}
6626
6627#define QEMU_VM_FILE_MAGIC 0x5145564d
faea38e7 6628#define QEMU_VM_FILE_VERSION 0x00000002
8a7ddc38 6629
9596ebb7 6630static int qemu_savevm_state(QEMUFile *f)
8a7ddc38
FB		 6631{
6632 SaveStateEntry *se;
faea38e7
FB		 6633 int len, ret;
6634 int64_t cur_pos, len_pos, total_len_pos;
313aa567 6635
8a7ddc38
FB		 6636 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
6637 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
faea38e7
FB		 6638 total_len_pos = qemu_ftell(f);
6639 qemu_put_be64(f, 0); /* total size */
8a7ddc38
FB		 6640
6641 for(se = first_se; se != NULL; se = se->next) {
d978c02c
AJ		 6642 if (se->save_state == NULL)
6643 /* this one has a loader only, for backwards compatibility */
6644 continue;
6645
8a7ddc38
FB		 6646 /* ID string */
6647 len = strlen(se->idstr);
6648 qemu_put_byte(f, len);
ffe8ab83 6649 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
8a7ddc38
FB		 6650
6651 qemu_put_be32(f, se->instance_id);
6652 qemu_put_be32(f, se->version_id);
6653
6654 /* record size: filled later */
faea38e7 6655 len_pos = qemu_ftell(f);
8a7ddc38 6656 qemu_put_be32(f, 0);
8a7ddc38
FB		 6657 se->save_state(f, se->opaque);
6658
6659 /* fill record size */
faea38e7
FB		 6660 cur_pos = qemu_ftell(f);
6661 len = cur_pos - len_pos - 4;
6662 qemu_fseek(f, len_pos, SEEK_SET);
8a7ddc38 6663 qemu_put_be32(f, len);
faea38e7 6664 qemu_fseek(f, cur_pos, SEEK_SET);
8a7ddc38 6665 }
faea38e7
FB		 6666 cur_pos = qemu_ftell(f);
6667 qemu_fseek(f, total_len_pos, SEEK_SET);
6668 qemu_put_be64(f, cur_pos - total_len_pos - 8);
6669 qemu_fseek(f, cur_pos, SEEK_SET);
8a7ddc38 6670
8a7ddc38 6671 ret = 0;
8a7ddc38
FB		 6672 return ret;
6673}
6674
6675static SaveStateEntry *find_se(const char *idstr, int instance_id)
6676{
6677 SaveStateEntry *se;
6678
6679 for(se = first_se; se != NULL; se = se->next) {
5fafdf24 6680 if (!strcmp(se->idstr, idstr) &&
8a7ddc38
FB		 6681 instance_id == se->instance_id)
6682 return se;
6683 }
6684 return NULL;
6685}
6686
9596ebb7 6687static int qemu_loadvm_state(QEMUFile *f)
8a7ddc38
FB		 6688{
6689 SaveStateEntry *se;
faea38e7
FB		 6690 int len, ret, instance_id, record_len, version_id;
6691 int64_t total_len, end_pos, cur_pos;
8a7ddc38
FB		 6692 unsigned int v;
6693 char idstr[256];
3b46e624 6694
8a7ddc38
FB		 6695 v = qemu_get_be32(f);
6696 if (v != QEMU_VM_FILE_MAGIC)
6697 goto fail;
6698 v = qemu_get_be32(f);
6699 if (v != QEMU_VM_FILE_VERSION) {
6700 fail:
8a7ddc38
FB		 6701 ret = -1;
6702 goto the_end;
6703 }
faea38e7
FB		 6704 total_len = qemu_get_be64(f);
6705 end_pos = total_len + qemu_ftell(f);
b4608c04 6706 for(;;) {
faea38e7 6707 if (qemu_ftell(f) >= end_pos)
cd4c3e88 6708 break;
faea38e7 6709 len = qemu_get_byte(f);
ffe8ab83 6710 qemu_get_buffer(f, (uint8_t *)idstr, len);
8a7ddc38
FB		 6711 idstr[len] = '\0';
6712 instance_id = qemu_get_be32(f);
6713 version_id = qemu_get_be32(f);
6714 record_len = qemu_get_be32(f);
6715#if 0
5fafdf24 6716 printf("idstr=%s instance=0x%x version=%d len=%d\n",
8a7ddc38
FB		 6717 idstr, instance_id, version_id, record_len);
6718#endif
faea38e7 6719 cur_pos = qemu_ftell(f);
8a7ddc38
FB		 6720 se = find_se(idstr, instance_id);
6721 if (!se) {
5fafdf24 6722 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
8a7ddc38
FB		 6723 instance_id, idstr);
6724 } else {
6725 ret = se->load_state(f, se->opaque, version_id);
6726 if (ret < 0) {
5fafdf24 6727 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
8a7ddc38
FB		 6728 instance_id, idstr);
6729 }
34865134 6730 }
8a7ddc38
FB		 6731 /* always seek to exact end of record */
6732 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6733 }
8a7ddc38 6734 ret = 0;
faea38e7
FB		 6735 the_end:
6736 return ret;
6737}
6738
6739/* device can contain snapshots */
6740static int bdrv_can_snapshot(BlockDriverState *bs)
6741{
6742 return (bs &&
6743 !bdrv_is_removable(bs) &&
6744 !bdrv_is_read_only(bs));
6745}
6746
6747/* device must be snapshots in order to have a reliable snapshot */
6748static int bdrv_has_snapshot(BlockDriverState *bs)
6749{
6750 return (bs &&
6751 !bdrv_is_removable(bs) &&
6752 !bdrv_is_read_only(bs));
6753}
6754
6755static BlockDriverState *get_bs_snapshots(void)
6756{
6757 BlockDriverState *bs;
6758 int i;
6759
6760 if (bs_snapshots)
6761 return bs_snapshots;
e4bcb14c
TS		 6762 for(i = 0; i <= nb_drives; i++) {
6763 bs = drives_table[i].bdrv;
faea38e7
FB		 6764 if (bdrv_can_snapshot(bs))
6765 goto ok;
6766 }
6767 return NULL;
6768 ok:
6769 bs_snapshots = bs;
6770 return bs;
6771}
6772
6773static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6774 const char *name)
6775{
6776 QEMUSnapshotInfo *sn_tab, *sn;
6777 int nb_sns, i, ret;
3b46e624 6778
faea38e7
FB		 6779 ret = -ENOENT;
6780 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6781 if (nb_sns < 0)
6782 return ret;
6783 for(i = 0; i < nb_sns; i++) {
6784 sn = &sn_tab[i];
6785 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6786 *sn_info = *sn;
6787 ret = 0;
6788 break;
6789 }
6790 }
6791 qemu_free(sn_tab);
6792 return ret;
6793}
6794
6795void do_savevm(const char *name)
6796{
6797 BlockDriverState *bs, *bs1;
6798 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6799 int must_delete, ret, i;
6800 BlockDriverInfo bdi1, *bdi = &bdi1;
6801 QEMUFile *f;
6802 int saved_vm_running;
4c279bdf
FB		 6803#ifdef _WIN32
6804 struct _timeb tb;
6805#else
faea38e7 6806 struct timeval tv;
4c279bdf 6807#endif
faea38e7
FB		 6808
6809 bs = get_bs_snapshots();
6810 if (!bs) {
6811 term_printf("No block device can accept snapshots\n");
6812 return;
6813 }
6814
6192bc37
PB		 6815 /* ??? Should this occur after vm_stop? */
6816 qemu_aio_flush();
6817
faea38e7
FB		 6818 saved_vm_running = vm_running;
6819 vm_stop(0);
3b46e624 6820
faea38e7
FB		 6821 must_delete = 0;
6822 if (name) {
6823 ret = bdrv_snapshot_find(bs, old_sn, name);
6824 if (ret >= 0) {
6825 must_delete = 1;
6826 }
6827 }
6828 memset(sn, 0, sizeof(*sn));
6829 if (must_delete) {
6830 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6831 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6832 } else {
6833 if (name)
6834 pstrcpy(sn->name, sizeof(sn->name), name);
6835 }
6836
6837 /* fill auxiliary fields */
4c279bdf
FB		 6838#ifdef _WIN32
6839 _ftime(&tb);
6840 sn->date_sec = tb.time;
6841 sn->date_nsec = tb.millitm * 1000000;
6842#else
faea38e7
FB		 6843 gettimeofday(&tv, NULL);
6844 sn->date_sec = tv.tv_sec;
6845 sn->date_nsec = tv.tv_usec * 1000;
4c279bdf 6846#endif
faea38e7 6847 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
3b46e624 6848
faea38e7
FB		 6849 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6850 term_printf("Device %s does not support VM state snapshots\n",
6851 bdrv_get_device_name(bs));
6852 goto the_end;
6853 }
3b46e624 6854
faea38e7
FB		 6855 /* save the VM state */
6856 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6857 if (!f) {
6858 term_printf("Could not open VM state file\n");
6859 goto the_end;
6860 }
6861 ret = qemu_savevm_state(f);
6862 sn->vm_state_size = qemu_ftell(f);
6863 qemu_fclose(f);
6864 if (ret < 0) {
6865 term_printf("Error %d while writing VM\n", ret);
6866 goto the_end;
6867 }
3b46e624 6868
faea38e7
FB		 6869 /* create the snapshots */
6870
e4bcb14c
TS		 6871 for(i = 0; i < nb_drives; i++) {
6872 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6873 if (bdrv_has_snapshot(bs1)) {
6874 if (must_delete) {
6875 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6876 if (ret < 0) {
6877 term_printf("Error while deleting snapshot on '%s'\n",
6878 bdrv_get_device_name(bs1));
6879 }
6880 }
6881 ret = bdrv_snapshot_create(bs1, sn);
6882 if (ret < 0) {
6883 term_printf("Error while creating snapshot on '%s'\n",
6884 bdrv_get_device_name(bs1));
6885 }
6886 }
6887 }
6888
8a7ddc38
FB		 6889 the_end:
6890 if (saved_vm_running)
6891 vm_start();
faea38e7
FB		 6892}
6893
6894void do_loadvm(const char *name)
6895{
6896 BlockDriverState *bs, *bs1;
6897 BlockDriverInfo bdi1, *bdi = &bdi1;
6898 QEMUFile *f;
6899 int i, ret;
6900 int saved_vm_running;
6901
6902 bs = get_bs_snapshots();
6903 if (!bs) {
6904 term_printf("No block device supports snapshots\n");
6905 return;
6906 }
3b46e624 6907
6192bc37
PB		 6908 /* Flush all IO requests so they don't interfere with the new state. */
6909 qemu_aio_flush();
6910
faea38e7
FB		 6911 saved_vm_running = vm_running;
6912 vm_stop(0);
6913
e4bcb14c
TS		 6914 for(i = 0; i <= nb_drives; i++) {
6915 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6916 if (bdrv_has_snapshot(bs1)) {
6917 ret = bdrv_snapshot_goto(bs1, name);
6918 if (ret < 0) {
6919 if (bs != bs1)
6920 term_printf("Warning: ");
6921 switch(ret) {
6922 case -ENOTSUP:
6923 term_printf("Snapshots not supported on device '%s'\n",
6924 bdrv_get_device_name(bs1));
6925 break;
6926 case -ENOENT:
6927 term_printf("Could not find snapshot '%s' on device '%s'\n",
6928 name, bdrv_get_device_name(bs1));
6929 break;
6930 default:
6931 term_printf("Error %d while activating snapshot on '%s'\n",
6932 ret, bdrv_get_device_name(bs1));
6933 break;
6934 }
6935 /* fatal on snapshot block device */
6936 if (bs == bs1)
6937 goto the_end;
6938 }
6939 }
6940 }
6941
6942 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6943 term_printf("Device %s does not support VM state snapshots\n",
6944 bdrv_get_device_name(bs));
6945 return;
6946 }
3b46e624 6947
faea38e7
FB		 6948 /* restore the VM state */
6949 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6950 if (!f) {
6951 term_printf("Could not open VM state file\n");
6952 goto the_end;
6953 }
6954 ret = qemu_loadvm_state(f);
6955 qemu_fclose(f);
6956 if (ret < 0) {
6957 term_printf("Error %d while loading VM state\n", ret);
6958 }
6959 the_end:
6960 if (saved_vm_running)
6961 vm_start();
6962}
6963
6964void do_delvm(const char *name)
6965{
6966 BlockDriverState *bs, *bs1;
6967 int i, ret;
6968
6969 bs = get_bs_snapshots();
6970 if (!bs) {
6971 term_printf("No block device supports snapshots\n");
6972 return;
6973 }
3b46e624 6974
e4bcb14c
TS		 6975 for(i = 0; i <= nb_drives; i++) {
6976 bs1 = drives_table[i].bdrv;
faea38e7
FB		 6977 if (bdrv_has_snapshot(bs1)) {
6978 ret = bdrv_snapshot_delete(bs1, name);
6979 if (ret < 0) {
6980 if (ret == -ENOTSUP)
6981 term_printf("Snapshots not supported on device '%s'\n",
6982 bdrv_get_device_name(bs1));
6983 else
6984 term_printf("Error %d while deleting snapshot on '%s'\n",
6985 ret, bdrv_get_device_name(bs1));
6986 }
6987 }
6988 }
6989}
6990
6991void do_info_snapshots(void)
6992{
6993 BlockDriverState *bs, *bs1;
6994 QEMUSnapshotInfo *sn_tab, *sn;
6995 int nb_sns, i;
6996 char buf[256];
6997
6998 bs = get_bs_snapshots();
6999 if (!bs) {
7000 term_printf("No available block device supports snapshots\n");
7001 return;
7002 }
7003 term_printf("Snapshot devices:");
e4bcb14c
TS		 7004 for(i = 0; i <= nb_drives; i++) {
7005 bs1 = drives_table[i].bdrv;
faea38e7
FB		 7006 if (bdrv_has_snapshot(bs1)) {
7007 if (bs == bs1)
7008 term_printf(" %s", bdrv_get_device_name(bs1));
7009 }
7010 }
7011 term_printf("\n");
7012
7013 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
7014 if (nb_sns < 0) {
7015 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
7016 return;
7017 }
7018 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
7019 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
7020 for(i = 0; i < nb_sns; i++) {
7021 sn = &sn_tab[i];
7022 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
7023 }
7024 qemu_free(sn_tab);
8a7ddc38
FB		 7025}
7026
8a7ddc38
FB		 7027/***********************************************************/
7028/* ram save/restore */
7029
8a7ddc38
FB		 7030static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
7031{
7032 int v;
7033
7034 v = qemu_get_byte(f);
7035 switch(v) {
7036 case 0:
7037 if (qemu_get_buffer(f, buf, len) != len)
7038 return -EIO;
7039 break;
7040 case 1:
7041 v = qemu_get_byte(f);
7042 memset(buf, v, len);
7043 break;
7044 default:
7045 return -EINVAL;
7046 }
7047 return 0;
7048}
7049
c88676f8
FB		 7050static int ram_load_v1(QEMUFile *f, void *opaque)
7051{
00f82b8a
AJ		 7052 int ret;
7053 ram_addr_t i;
c88676f8
FB		 7054
7055 if (qemu_get_be32(f) != phys_ram_size)
7056 return -EINVAL;
7057 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
7058 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
7059 if (ret)
7060 return ret;
7061 }
7062 return 0;
7063}
7064
7065#define BDRV_HASH_BLOCK_SIZE 1024
7066#define IOBUF_SIZE 4096
7067#define RAM_CBLOCK_MAGIC 0xfabe
7068
7069typedef struct RamCompressState {
7070 z_stream zstream;
7071 QEMUFile *f;
7072 uint8_t buf[IOBUF_SIZE];
7073} RamCompressState;
7074
7075static int ram_compress_open(RamCompressState *s, QEMUFile *f)
7076{
7077 int ret;
7078 memset(s, 0, sizeof(*s));
7079 s->f = f;
7080 ret = deflateInit2(&s->zstream, 1,
5fafdf24 7081 Z_DEFLATED, 15,
c88676f8
FB		 7082 9, Z_DEFAULT_STRATEGY);
7083 if (ret != Z_OK)
7084 return -1;
7085 s->zstream.avail_out = IOBUF_SIZE;
7086 s->zstream.next_out = s->buf;
7087 return 0;
7088}
7089
7090static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
7091{
7092 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
7093 qemu_put_be16(s->f, len);
7094 qemu_put_buffer(s->f, buf, len);
7095}
7096
7097static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
7098{
7099 int ret;
7100
7101 s->zstream.avail_in = len;
7102 s->zstream.next_in = (uint8_t *)buf;
7103 while (s->zstream.avail_in > 0) {
7104 ret = deflate(&s->zstream, Z_NO_FLUSH);
7105 if (ret != Z_OK)
7106 return -1;
7107 if (s->zstream.avail_out == 0) {
7108 ram_put_cblock(s, s->buf, IOBUF_SIZE);
7109 s->zstream.avail_out = IOBUF_SIZE;
7110 s->zstream.next_out = s->buf;
7111 }
7112 }
7113 return 0;
7114}
7115
7116static void ram_compress_close(RamCompressState *s)
7117{
7118 int len, ret;
7119
7120 /* compress last bytes */
7121 for(;;) {
7122 ret = deflate(&s->zstream, Z_FINISH);
7123 if (ret == Z_OK || ret == Z_STREAM_END) {
7124 len = IOBUF_SIZE - s->zstream.avail_out;
7125 if (len > 0) {
7126 ram_put_cblock(s, s->buf, len);
7127 }
7128 s->zstream.avail_out = IOBUF_SIZE;
7129 s->zstream.next_out = s->buf;
7130 if (ret == Z_STREAM_END)
7131 break;
7132 } else {
7133 goto fail;
7134 }
7135 }
7136fail:
7137 deflateEnd(&s->zstream);
7138}
7139
7140typedef struct RamDecompressState {
7141 z_stream zstream;
7142 QEMUFile *f;
7143 uint8_t buf[IOBUF_SIZE];
7144} RamDecompressState;
7145
7146static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
7147{
7148 int ret;
7149 memset(s, 0, sizeof(*s));
7150 s->f = f;
7151 ret = inflateInit(&s->zstream);
7152 if (ret != Z_OK)
7153 return -1;
7154 return 0;
7155}
7156
7157static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
7158{
7159 int ret, clen;
7160
7161 s->zstream.avail_out = len;
7162 s->zstream.next_out = buf;
7163 while (s->zstream.avail_out > 0) {
7164 if (s->zstream.avail_in == 0) {
7165 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
7166 return -1;
7167 clen = qemu_get_be16(s->f);
7168 if (clen > IOBUF_SIZE)
7169 return -1;
7170 qemu_get_buffer(s->f, s->buf, clen);
7171 s->zstream.avail_in = clen;
7172 s->zstream.next_in = s->buf;
7173 }
7174 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
7175 if (ret != Z_OK && ret != Z_STREAM_END) {
7176 return -1;
7177 }
7178 }
7179 return 0;
7180}
7181
7182static void ram_decompress_close(RamDecompressState *s)
7183{
7184 inflateEnd(&s->zstream);
7185}
7186
8a7ddc38
FB		 7187static void ram_save(QEMUFile *f, void *opaque)
7188{
00f82b8a 7189 ram_addr_t i;
c88676f8
FB		 7190 RamCompressState s1, *s = &s1;
7191 uint8_t buf[10];
3b46e624 7192
8a7ddc38 7193 qemu_put_be32(f, phys_ram_size);
c88676f8
FB		 7194 if (ram_compress_open(s, f) < 0)
7195 return;
7196 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7197#if 0
7198 if (tight_savevm_enabled) {
7199 int64_t sector_num;
7200 int j;
7201
7202 /* find if the memory block is available on a virtual
7203 block device */
7204 sector_num = -1;
e4bcb14c
TS		 7205 for(j = 0; j < nb_drives; j++) {
7206 sector_num = bdrv_hash_find(drives_table[j].bdrv,
7207 phys_ram_base + i,
7208 BDRV_HASH_BLOCK_SIZE);
7209 if (sector_num >= 0)
7210 break;
c88676f8 7211 }
e4bcb14c 7212 if (j == nb_drives)
c88676f8
FB		 7213 goto normal_compress;
7214 buf[0] = 1;
7215 buf[1] = j;
7216 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
7217 ram_compress_buf(s, buf, 10);
5fafdf24 7218 } else
c88676f8
FB		 7219#endif
7220 {
7221 // normal_compress:
7222 buf[0] = 0;
7223 ram_compress_buf(s, buf, 1);
7224 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7225 }
8a7ddc38 7226 }
c88676f8 7227 ram_compress_close(s);
8a7ddc38
FB		 7228}
7229
7230static int ram_load(QEMUFile *f, void *opaque, int version_id)
7231{
c88676f8
FB		 7232 RamDecompressState s1, *s = &s1;
7233 uint8_t buf[10];
00f82b8a 7234 ram_addr_t i;
8a7ddc38 7235
c88676f8
FB		 7236 if (version_id == 1)
7237 return ram_load_v1(f, opaque);
7238 if (version_id != 2)
8a7ddc38
FB		 7239 return -EINVAL;
7240 if (qemu_get_be32(f) != phys_ram_size)
7241 return -EINVAL;
c88676f8
FB		 7242 if (ram_decompress_open(s, f) < 0)
7243 return -EINVAL;
7244 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7245 if (ram_decompress_buf(s, buf, 1) < 0) {
7246 fprintf(stderr, "Error while reading ram block header\n");
7247 goto error;
7248 }
7249 if (buf[0] == 0) {
7250 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
00f82b8a 7251 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
c88676f8
FB		 7252 goto error;
7253 }
5fafdf24 7254 } else
c88676f8
FB		 7255#if 0
7256 if (buf[0] == 1) {
7257 int bs_index;
7258 int64_t sector_num;
7259
7260 ram_decompress_buf(s, buf + 1, 9);
7261 bs_index = buf[1];
7262 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
e4bcb14c 7263 if (bs_index >= nb_drives) {
c88676f8
FB		 7264 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7265 goto error;
7266 }
e4bcb14c
TS		 7267 if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7268 phys_ram_base + i,
c88676f8 7269 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
5fafdf24 7270 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
c88676f8
FB		 7271 bs_index, sector_num);
7272 goto error;
7273 }
5fafdf24 7274 } else
c88676f8
FB		 7275#endif
7276 {
7277 error:
7278 printf("Error block header\n");
7279 return -EINVAL;
7280 }
8a7ddc38 7281 }
c88676f8 7282 ram_decompress_close(s);
8a7ddc38
FB		 7283 return 0;
7284}
7285
83f64091
FB		 7286/***********************************************************/
7287/* bottom halves (can be seen as timers which expire ASAP) */
7288
7289struct QEMUBH {
7290 QEMUBHFunc *cb;
7291 void *opaque;
7292 int scheduled;
7293 QEMUBH *next;
7294};
7295
7296static QEMUBH *first_bh = NULL;
7297
7298QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7299{
7300 QEMUBH *bh;
7301 bh = qemu_mallocz(sizeof(QEMUBH));
7302 if (!bh)
7303 return NULL;
7304 bh->cb = cb;
7305 bh->opaque = opaque;
7306 return bh;
7307}
7308
6eb5733a 7309int qemu_bh_poll(void)
83f64091
FB		 7310{
7311 QEMUBH *bh, **pbh;
6eb5733a 7312 int ret;
83f64091 7313
6eb5733a 7314 ret = 0;
83f64091
FB		 7315 for(;;) {
7316 pbh = &first_bh;
7317 bh = *pbh;
7318 if (!bh)
7319 break;
6eb5733a 7320 ret = 1;
83f64091
FB		 7321 *pbh = bh->next;
7322 bh->scheduled = 0;
7323 bh->cb(bh->opaque);
7324 }
6eb5733a 7325 return ret;
83f64091
FB		 7326}
7327
7328void qemu_bh_schedule(QEMUBH *bh)
7329{
7330 CPUState *env = cpu_single_env;
7331 if (bh->scheduled)
7332 return;
7333 bh->scheduled = 1;
7334 bh->next = first_bh;
7335 first_bh = bh;
7336
7337 /* stop the currently executing CPU to execute the BH ASAP */
7338 if (env) {
7339 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7340 }
7341}
7342
7343void qemu_bh_cancel(QEMUBH *bh)
7344{
7345 QEMUBH **pbh;
7346 if (bh->scheduled) {
7347 pbh = &first_bh;
7348 while (*pbh != bh)
7349 pbh = &(*pbh)->next;
7350 *pbh = bh->next;
7351 bh->scheduled = 0;
7352 }
7353}
7354
7355void qemu_bh_delete(QEMUBH *bh)
7356{
7357 qemu_bh_cancel(bh);
7358 qemu_free(bh);
7359}
7360
cc1daa40
FB		 7361/***********************************************************/
7362/* machine registration */
7363
7364QEMUMachine *first_machine = NULL;
7365
7366int qemu_register_machine(QEMUMachine *m)
7367{
7368 QEMUMachine **pm;
7369 pm = &first_machine;
7370 while (*pm != NULL)
7371 pm = &(*pm)->next;
7372 m->next = NULL;
7373 *pm = m;
7374 return 0;
7375}
7376
9596ebb7 7377static QEMUMachine *find_machine(const char *name)
cc1daa40
FB		 7378{
7379 QEMUMachine *m;
7380
7381 for(m = first_machine; m != NULL; m = m->next) {
7382 if (!strcmp(m->name, name))
7383 return m;
7384 }
7385 return NULL;
7386}
7387
8a7ddc38
FB		 7388/***********************************************************/
7389/* main execution loop */
7390
9596ebb7 7391static void gui_update(void *opaque)
8a7ddc38 7392{
740733bb
TS		 7393 DisplayState *ds = opaque;
7394 ds->dpy_refresh(ds);
f442e08b
AJ		 7395 qemu_mod_timer(ds->gui_timer,
7396 (ds->gui_timer_interval ?
7397 ds->gui_timer_interval :
7398 GUI_REFRESH_INTERVAL)
7399 + qemu_get_clock(rt_clock));
8a7ddc38
FB		 7400}
7401
0bd48850
FB		 7402struct vm_change_state_entry {
7403 VMChangeStateHandler *cb;
7404 void *opaque;
7405 LIST_ENTRY (vm_change_state_entry) entries;
7406};
7407
7408static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7409
7410VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7411 void *opaque)
7412{
7413 VMChangeStateEntry *e;
7414
7415 e = qemu_mallocz(sizeof (*e));
7416 if (!e)
7417 return NULL;
7418
7419 e->cb = cb;
7420 e->opaque = opaque;
7421 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7422 return e;
7423}
7424
7425void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7426{
7427 LIST_REMOVE (e, entries);
7428 qemu_free (e);
7429}
7430
7431static void vm_state_notify(int running)
7432{
7433 VMChangeStateEntry *e;
7434
7435 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7436 e->cb(e->opaque, running);
7437 }
7438}
7439
8a7ddc38 7440/* XXX: support several handlers */
0bd48850
FB		 7441static VMStopHandler *vm_stop_cb;
7442static void *vm_stop_opaque;
8a7ddc38
FB		 7443
7444int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7445{
7446 vm_stop_cb = cb;
7447 vm_stop_opaque = opaque;
7448 return 0;
7449}
7450
7451void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7452{
7453 vm_stop_cb = NULL;
7454}
7455
7456void vm_start(void)
7457{
7458 if (!vm_running) {
7459 cpu_enable_ticks();
7460 vm_running = 1;
0bd48850 7461 vm_state_notify(1);
efe75411 7462 qemu_rearm_alarm_timer(alarm_timer);
8a7ddc38
FB		 7463 }
7464}
7465
5fafdf24 7466void vm_stop(int reason)
8a7ddc38
FB		 7467{
7468 if (vm_running) {
7469 cpu_disable_ticks();
7470 vm_running = 0;
7471 if (reason != 0) {
7472 if (vm_stop_cb) {
7473 vm_stop_cb(vm_stop_opaque, reason);
7474 }
34865134 7475 }
0bd48850 7476 vm_state_notify(0);
8a7ddc38
FB		 7477 }
7478}
7479
bb0c6722
FB		 7480/* reset/shutdown handler */
7481
7482typedef struct QEMUResetEntry {
7483 QEMUResetHandler *func;
7484 void *opaque;
7485 struct QEMUResetEntry *next;
7486} QEMUResetEntry;
7487
7488static QEMUResetEntry *first_reset_entry;
7489static int reset_requested;
7490static int shutdown_requested;
3475187d 7491static int powerdown_requested;
bb0c6722 7492
cf7a2fe2
AJ		 7493int qemu_shutdown_requested(void)
7494{
7495 int r = shutdown_requested;
7496 shutdown_requested = 0;
7497 return r;
7498}
7499
7500int qemu_reset_requested(void)
7501{
7502 int r = reset_requested;
7503 reset_requested = 0;
7504 return r;
7505}
7506
7507int qemu_powerdown_requested(void)
7508{
7509 int r = powerdown_requested;
7510 powerdown_requested = 0;
7511 return r;
7512}
7513
bb0c6722
FB		 7514void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7515{
7516 QEMUResetEntry **pre, *re;
7517
7518 pre = &first_reset_entry;
7519 while (*pre != NULL)
7520 pre = &(*pre)->next;
7521 re = qemu_mallocz(sizeof(QEMUResetEntry));
7522 re->func = func;
7523 re->opaque = opaque;
7524 re->next = NULL;
7525 *pre = re;
7526}
7527
cf7a2fe2 7528void qemu_system_reset(void)
bb0c6722
FB		 7529{
7530 QEMUResetEntry *re;
7531
7532 /* reset all devices */
7533 for(re = first_reset_entry; re != NULL; re = re->next) {
7534 re->func(re->opaque);
7535 }
7536}
7537
7538void qemu_system_reset_request(void)
7539{
d1beab82
FB		 7540 if (no_reboot) {
7541 shutdown_requested = 1;
7542 } else {
7543 reset_requested = 1;
7544 }
6a00d601
FB		 7545 if (cpu_single_env)
7546 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7547}
7548
7549void qemu_system_shutdown_request(void)
7550{
7551 shutdown_requested = 1;
6a00d601
FB		 7552 if (cpu_single_env)
7553 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7554}
7555
3475187d
FB		 7556void qemu_system_powerdown_request(void)
7557{
7558 powerdown_requested = 1;
6a00d601
FB		 7559 if (cpu_single_env)
7560 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 7561}
7562
5905b2e5 7563void main_loop_wait(int timeout)
8a7ddc38 7564{
cafffd40 7565 IOHandlerRecord *ioh;
e035649e 7566 fd_set rfds, wfds, xfds;
877cf882
TS		 7567 int ret, nfds;
7568#ifdef _WIN32
7569 int ret2, i;
7570#endif
fd1dff4b 7571 struct timeval tv;
f331110f
FB		 7572 PollingEntry *pe;
7573
c4b1fcc0 7574
f331110f
FB		 7575 /* XXX: need to suppress polling by better using win32 events */
7576 ret = 0;
7577 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7578 ret |= pe->func(pe->opaque);
7579 }
38e205a2 7580#ifdef _WIN32
e6b1e558 7581 if (ret == 0) {
a18e524a
FB		 7582 int err;
7583 WaitObjects *w = &wait_objects;
3b46e624 7584
a18e524a
FB		 7585 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7586 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7587 if (w->func[ret - WAIT_OBJECT_0])
7588 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3b46e624 7589
5fafdf24 7590 /* Check for additional signaled events */
e6b1e558 7591 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3b46e624 7592
e6b1e558
TS		 7593 /* Check if event is signaled */
7594 ret2 = WaitForSingleObject(w->events[i], 0);
7595 if(ret2 == WAIT_OBJECT_0) {
7596 if (w->func[i])
7597 w->func[i](w->opaque[i]);
7598 } else if (ret2 == WAIT_TIMEOUT) {
7599 } else {
7600 err = GetLastError();
7601 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3b46e624
TS		 7602 }
7603 }
a18e524a
FB		 7604 } else if (ret == WAIT_TIMEOUT) {
7605 } else {
7606 err = GetLastError();
e6b1e558 7607 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
a18e524a 7608 }
f331110f 7609 }
fd1dff4b
FB		 7610#endif
7611 /* poll any events */
7612 /* XXX: separate device handlers from system ones */
7613 nfds = -1;
7614 FD_ZERO(&rfds);
7615 FD_ZERO(&wfds);
e035649e 7616 FD_ZERO(&xfds);
fd1dff4b 7617 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
cafffd40
TS		 7618 if (ioh->deleted)
7619 continue;
fd1dff4b
FB		 7620 if (ioh->fd_read &&
7621 (!ioh->fd_read_poll ||
7622 ioh->fd_read_poll(ioh->opaque) != 0)) {
7623 FD_SET(ioh->fd, &rfds);
7624 if (ioh->fd > nfds)
7625 nfds = ioh->fd;
7626 }
7627 if (ioh->fd_write) {
7628 FD_SET(ioh->fd, &wfds);
7629 if (ioh->fd > nfds)
7630 nfds = ioh->fd;
7631 }
7632 }
3b46e624 7633
fd1dff4b
FB		 7634 tv.tv_sec = 0;
7635#ifdef _WIN32
7636 tv.tv_usec = 0;
38e205a2 7637#else
fd1dff4b
FB		 7638 tv.tv_usec = timeout * 1000;
7639#endif
e035649e
FB		 7640#if defined(CONFIG_SLIRP)
7641 if (slirp_inited) {
7642 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7643 }
7644#endif
7645 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
fd1dff4b 7646 if (ret > 0) {
cafffd40
TS		 7647 IOHandlerRecord **pioh;
7648
7649 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6ab43fdc 7650 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
fd1dff4b 7651 ioh->fd_read(ioh->opaque);
7c9d8e07 7652 }
6ab43fdc 7653 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
fd1dff4b 7654 ioh->fd_write(ioh->opaque);
c4b1fcc0 7655 }
b4608c04 7656 }
cafffd40
TS		 7657
7658 /* remove deleted IO handlers */
7659 pioh = &first_io_handler;
7660 while (*pioh) {
7661 ioh = *pioh;
7662 if (ioh->deleted) {
7663 *pioh = ioh->next;
7664 qemu_free(ioh);
5fafdf24 7665 } else
cafffd40
TS		 7666 pioh = &ioh->next;
7667 }
fd1dff4b 7668 }
c20709aa 7669#if defined(CONFIG_SLIRP)
fd1dff4b 7670 if (slirp_inited) {
e035649e
FB		 7671 if (ret < 0) {
7672 FD_ZERO(&rfds);
7673 FD_ZERO(&wfds);
7674 FD_ZERO(&xfds);
c20709aa 7675 }
e035649e 7676 slirp_select_poll(&rfds, &wfds, &xfds);
fd1dff4b 7677 }
e035649e 7678#endif
b4608c04 7679
fd1dff4b 7680 if (vm_running) {
21b20814 7681 if (likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
5fafdf24 7682 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
fd1dff4b
FB		 7683 qemu_get_clock(vm_clock));
7684 /* run dma transfers, if any */
7685 DMA_run();
7686 }
423f0742 7687
fd1dff4b 7688 /* real time timers */
5fafdf24 7689 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
fd1dff4b 7690 qemu_get_clock(rt_clock));
423f0742 7691
d5d08334
AZ		 7692 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7693 alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7694 qemu_rearm_alarm_timer(alarm_timer);
7695 }
b99dc0d1 7696
423f0742
PB		 7697 /* Check bottom-halves last in case any of the earlier events triggered
7698 them. */
7699 qemu_bh_poll();
3b46e624 7700
5905b2e5
FB		 7701}
7702
9596ebb7 7703static int main_loop(void)
5905b2e5
FB		 7704{
7705 int ret, timeout;
89bfc105
FB		 7706#ifdef CONFIG_PROFILER
7707 int64_t ti;
7708#endif
6a00d601 7709 CPUState *env;
5905b2e5 7710
6a00d601 7711 cur_cpu = first_cpu;
ee5605e5 7712 next_cpu = cur_cpu->next_cpu ?: first_cpu;
5905b2e5
FB		 7713 for(;;) {
7714 if (vm_running) {
15a76449 7715
15a76449
FB		 7716 for(;;) {
7717 /* get next cpu */
ee5605e5 7718 env = next_cpu;
89bfc105
FB		 7719#ifdef CONFIG_PROFILER
7720 ti = profile_getclock();
7721#endif
2e70f6ef
PB		 7722 if (use_icount) {
7723 int64_t count;
7724 int decr;
7725 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
7726 env->icount_decr.u16.low = 0;
7727 env->icount_extra = 0;
7728 count = qemu_next_deadline();
7729 count = (count + (1 << icount_time_shift) - 1)
7730 >> icount_time_shift;
7731 qemu_icount += count;
7732 decr = (count > 0xffff) ? 0xffff : count;
7733 count -= decr;
7734 env->icount_decr.u16.low = decr;
7735 env->icount_extra = count;
7736 }
6a00d601 7737 ret = cpu_exec(env);
89bfc105
FB		 7738#ifdef CONFIG_PROFILER
7739 qemu_time += profile_getclock() - ti;
7740#endif
2e70f6ef
PB		 7741 if (use_icount) {
7742 /* Fold pending instructions back into the
7743 instruction counter, and clear the interrupt flag. */
7744 qemu_icount -= (env->icount_decr.u16.low
7745 + env->icount_extra);
7746 env->icount_decr.u32 = 0;
7747 env->icount_extra = 0;
7748 }
ee5605e5 7749 next_cpu = env->next_cpu ?: first_cpu;
95b01009 7750 if (event_pending && likely(ret != EXCP_DEBUG)) {
ee5605e5
AZ		 7751 ret = EXCP_INTERRUPT;
7752 event_pending = 0;
7753 break;
7754 }
bd967e05
PB		 7755 if (ret == EXCP_HLT) {
7756 /* Give the next CPU a chance to run. */
7757 cur_cpu = env;
7758 continue;
7759 }
15a76449
FB		 7760 if (ret != EXCP_HALTED)
7761 break;
7762 /* all CPUs are halted ? */
bd967e05 7763 if (env == cur_cpu)
15a76449 7764 break;
15a76449
FB		 7765 }
7766 cur_cpu = env;
7767
5905b2e5 7768 if (shutdown_requested) {
3475187d 7769 ret = EXCP_INTERRUPT;
b2f76161
AJ		 7770 if (no_shutdown) {
7771 vm_stop(0);
7772 no_shutdown = 0;
7773 }
7774 else
7775 break;
5905b2e5
FB		 7776 }
7777 if (reset_requested) {
7778 reset_requested = 0;
7779 qemu_system_reset();
3475187d
FB		 7780 ret = EXCP_INTERRUPT;
7781 }
7782 if (powerdown_requested) {
7783 powerdown_requested = 0;
7784 qemu_system_powerdown();
7785 ret = EXCP_INTERRUPT;
5905b2e5 7786 }
95b01009 7787 if (unlikely(ret == EXCP_DEBUG)) {
5905b2e5
FB		 7788 vm_stop(EXCP_DEBUG);
7789 }
bd967e05 7790 /* If all cpus are halted then wait until the next IRQ */
5905b2e5 7791 /* XXX: use timeout computed from timers */
2e70f6ef
PB		 7792 if (ret == EXCP_HALTED) {
7793 if (use_icount) {
7794 int64_t add;
7795 int64_t delta;
7796 /* Advance virtual time to the next event. */
7797 if (use_icount == 1) {
7798 /* When not using an adaptive execution frequency
7799 we tend to get badly out of sync with real time,
bf20dc07 7800 so just delay for a reasonable amount of time. */
2e70f6ef
PB		 7801 delta = 0;
7802 } else {
7803 delta = cpu_get_icount() - cpu_get_clock();
7804 }
7805 if (delta > 0) {
7806 /* If virtual time is ahead of real time then just
7807 wait for IO. */
7808 timeout = (delta / 1000000) + 1;
7809 } else {
7810 /* Wait for either IO to occur or the next
7811 timer event. */
7812 add = qemu_next_deadline();
7813 /* We advance the timer before checking for IO.
7814 Limit the amount we advance so that early IO
7815 activity won't get the guest too far ahead. */
7816 if (add > 10000000)
7817 add = 10000000;
7818 delta += add;
7819 add = (add + (1 << icount_time_shift) - 1)
7820 >> icount_time_shift;
7821 qemu_icount += add;
7822 timeout = delta / 1000000;
7823 if (timeout < 0)
7824 timeout = 0;
7825 }
7826 } else {
7827 timeout = 10;
7828 }
7829 } else {
5905b2e5 7830 timeout = 0;
2e70f6ef 7831 }
5905b2e5 7832 } else {
98448f58
BS		 7833 if (shutdown_requested) {
7834 ret = EXCP_INTERRUPT;
5b08fc10 7835 break;
98448f58 7836 }
5905b2e5
FB		 7837 timeout = 10;
7838 }
89bfc105
FB		 7839#ifdef CONFIG_PROFILER
7840 ti = profile_getclock();
7841#endif
5905b2e5 7842 main_loop_wait(timeout);
89bfc105
FB		 7843#ifdef CONFIG_PROFILER
7844 dev_time += profile_getclock() - ti;
7845#endif
b4608c04 7846 }
34865134
FB		 7847 cpu_disable_ticks();
7848 return ret;
b4608c04
FB		 7849}
7850
15f82208 7851static void help(int exitcode)
0824d6fc 7852{
68d0f70e 7853 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
0db63474 7854 "usage: %s [options] [disk_image]\n"
0824d6fc 7855 "\n"
a20dd508 7856 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
fc01f7e7 7857 "\n"
a20dd508 7858 "Standard options:\n"
cc1daa40 7859 "-M machine select emulated machine (-M ? for list)\n"
5adb4839 7860 "-cpu cpu select CPU (-cpu ? for list)\n"
c45886db 7861 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
36b486bb
FB		 7862 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7863 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
c4b1fcc0 7864 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
a1620fac
AJ		 7865 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7866 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7867 " [,cache=on|off][,format=f]\n"
e4bcb14c 7868 " use 'file' as a drive image\n"
3e3d5815 7869 "-mtdblock file use 'file' as on-board Flash memory image\n"
a1bb27b1 7870 "-sd file use 'file' as SecureDigital card image\n"
86f55663 7871 "-pflash file use 'file' as a parallel flash image\n"
eec85c2a 7872 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
667accab
TS		 7873 "-snapshot write to temporary files instead of disk image files\n"
7874#ifdef CONFIG_SDL
43523e93 7875 "-no-frame open SDL window without a frame and window decorations\n"
3780e197 7876 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
667accab
TS		 7877 "-no-quit disable SDL window close capability\n"
7878#endif
52ca8d6a
FB		 7879#ifdef TARGET_I386
7880 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7881#endif
a00bad7e 7882 "-m megs set virtual RAM size to megs MB [default=%d]\n"
91fc2119 7883 "-smp n set the number of CPUs to 'n' [default=1]\n"
c4b1fcc0 7884 "-nographic disable graphical output and redirect serial I/Os to console\n"
a171fe39 7885 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
4ca0074c 7886#ifndef _WIN32
667accab 7887 "-k language use keyboard layout (for example \"fr\" for French)\n"
4ca0074c 7888#endif
1d14ffa9 7889#ifdef HAS_AUDIO
1d14ffa9 7890 "-audio-help print list of audio drivers and their options\n"
c0fe3827
FB		 7891 "-soundhw c1,... enable audio support\n"
7892 " and only specified sound cards (comma separated list)\n"
7893 " use -soundhw ? to get the list of supported cards\n"
6a36d84e 7894 " use -soundhw all to enable all of them\n"
1d14ffa9 7895#endif
3893c124 7896 "-vga [std|cirrus|vmware]\n"
7897 " select video card type\n"
89980284 7898 "-localtime set the real time clock to local time [default=utc]\n"
d63d307f 7899 "-full-screen start in full screen\n"
a09db21f
FB		 7900#ifdef TARGET_I386
7901 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7902#endif
b389dbfb
FB		 7903 "-usb enable the USB driver (will be the default soon)\n"
7904 "-usbdevice name add the host or guest USB device 'name'\n"
6f7e9aec
FB		 7905#if defined(TARGET_PPC) || defined(TARGET_SPARC)
7906 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
bb0c6722 7907#endif
c35734b2 7908 "-name string set the name of the guest\n"
8fcb1b90 7909 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
c4b1fcc0
FB		 7910 "\n"
7911 "Network options:\n"
a41b2ff2 7912 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7c9d8e07 7913 " create a new Network Interface Card and connect it to VLAN 'n'\n"
c20709aa 7914#ifdef CONFIG_SLIRP
115defd1
PB		 7915 "-net user[,vlan=n][,hostname=host]\n"
7916 " connect the user mode network stack to VLAN 'n' and send\n"
7917 " hostname 'host' to DHCP clients\n"
7c9d8e07 7918#endif
7fb843f8
FB		 7919#ifdef _WIN32
7920 "-net tap[,vlan=n],ifname=name\n"
7921 " connect the host TAP network interface to VLAN 'n'\n"
7922#else
b46a8906
TS		 7923 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7924 " connect the host TAP network interface to VLAN 'n' and use the\n"
7925 " network scripts 'file' (default=%s)\n"
7926 " and 'dfile' (default=%s);\n"
7927 " use '[down]script=no' to disable script execution;\n"
7c9d8e07 7928 " use 'fd=h' to connect to an already opened TAP interface\n"
7fb843f8 7929#endif
6a00d601 7930 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7c9d8e07 7931 " connect the vlan 'n' to another VLAN using a socket connection\n"
3d830459
FB		 7932 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7933 " connect the vlan 'n' to multicast maddr and port\n"
8a16d273
TS		 7934#ifdef CONFIG_VDE
7935 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
7936 " connect the vlan 'n' to port 'n' of a vde switch running\n"
7937 " on host and listening for incoming connections on 'socketpath'.\n"
7938 " Use group 'groupname' and mode 'octalmode' to change default\n"
7939 " ownership and permissions for communication port.\n"
7940#endif
7c9d8e07
FB		 7941 "-net none use it alone to have zero network devices; if no -net option\n"
7942 " is provided, the default is '-net nic -net user'\n"
7943 "\n"
7944#ifdef CONFIG_SLIRP
0db1137d 7945 "-tftp dir allow tftp access to files in dir [-net user]\n"
47d5d01a 7946 "-bootp file advertise file in BOOTP replies\n"
7c9d8e07
FB		 7947#ifndef _WIN32
7948 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
c94c8d64 7949#endif
9bf05444 7950 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7c9d8e07 7951 " redirect TCP or UDP connections from host to guest [-net user]\n"
c20709aa 7952#endif
a20dd508 7953 "\n"
c4b1fcc0 7954 "Linux boot specific:\n"
a20dd508
FB		 7955 "-kernel bzImage use 'bzImage' as kernel image\n"
7956 "-append cmdline use 'cmdline' as kernel command line\n"
7957 "-initrd file use 'file' as initial ram disk\n"
fc01f7e7 7958 "\n"
330d0414 7959 "Debug/Expert options:\n"
82c643ff
FB		 7960 "-monitor dev redirect the monitor to char device 'dev'\n"
7961 "-serial dev redirect the serial port to char device 'dev'\n"
6508fe59 7962 "-parallel dev redirect the parallel port to char device 'dev'\n"
f7cce898 7963 "-pidfile file Write PID to 'file'\n"
cd6f1169 7964 "-S freeze CPU at startup (use 'c' to start execution)\n"
cfc3475a
PB		 7965 "-s wait gdb connection to port\n"
7966 "-p port set gdb connection port [default=%s]\n"
f193c797 7967 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
46d4767d
FB		 7968 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7969 " translation (t=none or lba) (usually qemu can guess them)\n"
87b47350 7970 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
d993e026 7971#ifdef USE_KQEMU
6515b203 7972 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
d993e026
FB		 7973 "-no-kqemu disable KQEMU kernel module usage\n"
7974#endif
bb0c6722 7975#ifdef TARGET_I386
6515b203 7976 "-no-acpi disable ACPI\n"
4d3b6f6e
AZ		 7977#endif
7978#ifdef CONFIG_CURSES
7979 "-curses use a curses/ncurses interface instead of SDL\n"
bb0c6722 7980#endif
d1beab82 7981 "-no-reboot exit instead of rebooting\n"
b2f76161 7982 "-no-shutdown stop before shutdown\n"
a8080006 7983 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
24236869 7984 "-vnc display start a VNC server on display\n"
71e3ceb8
TS		 7985#ifndef _WIN32
7986 "-daemonize daemonize QEMU after initializing\n"
7987#endif
9ae02555 7988 "-option-rom rom load a file, rom, into the option ROM space\n"
66508601
BS		 7989#ifdef TARGET_SPARC
7990 "-prom-env variable=value set OpenBIOS nvram variables\n"
7991#endif
f3dcfada 7992 "-clock force the use of the given methods for timer alarm.\n"
3adda04c 7993 " To see what timers are available use -clock ?\n"
bce61846 7994 "-startdate select initial date of the clock\n"
2e70f6ef 7995 "-icount [N|auto]\n"
dd5d6fe9 7996 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
0824d6fc 7997 "\n"
82c643ff 7998 "During emulation, the following keys are useful:\n"
032a8c9e
FB		 7999 "ctrl-alt-f toggle full screen\n"
8000 "ctrl-alt-n switch to virtual console 'n'\n"
8001 "ctrl-alt toggle mouse and keyboard grab\n"
82c643ff
FB		 8002 "\n"
8003 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8004 ,
0db63474 8005 "qemu",
a00bad7e 8006 DEFAULT_RAM_SIZE,
7c9d8e07 8007#ifndef _WIN32
a00bad7e 8008 DEFAULT_NETWORK_SCRIPT,
b46a8906 8009 DEFAULT_NETWORK_DOWN_SCRIPT,
7c9d8e07 8010#endif
6e44ba7f 8011 DEFAULT_GDBSTUB_PORT,
bce61846 8012 "/tmp/qemu.log");
15f82208 8013 exit(exitcode);
0824d6fc
FB		 8014}
8015
cd6f1169
FB		 8016#define HAS_ARG 0x0001
8017
8018enum {
8019 QEMU_OPTION_h,
8020
cc1daa40 8021 QEMU_OPTION_M,
94fc95cd 8022 QEMU_OPTION_cpu,
cd6f1169
FB		 8023 QEMU_OPTION_fda,
8024 QEMU_OPTION_fdb,
8025 QEMU_OPTION_hda,
8026 QEMU_OPTION_hdb,
8027 QEMU_OPTION_hdc,
8028 QEMU_OPTION_hdd,
e4bcb14c 8029 QEMU_OPTION_drive,
cd6f1169 8030 QEMU_OPTION_cdrom,
3e3d5815 8031 QEMU_OPTION_mtdblock,
a1bb27b1 8032 QEMU_OPTION_sd,
86f55663 8033 QEMU_OPTION_pflash,
cd6f1169
FB		 8034 QEMU_OPTION_boot,
8035 QEMU_OPTION_snapshot,
52ca8d6a
FB		 8036#ifdef TARGET_I386
8037 QEMU_OPTION_no_fd_bootchk,
8038#endif
cd6f1169
FB		 8039 QEMU_OPTION_m,
8040 QEMU_OPTION_nographic,
a171fe39 8041 QEMU_OPTION_portrait,
1d14ffa9 8042#ifdef HAS_AUDIO
1d14ffa9
FB		 8043 QEMU_OPTION_audio_help,
8044 QEMU_OPTION_soundhw,
8045#endif
cd6f1169 8046
7c9d8e07 8047 QEMU_OPTION_net,
c7f74643 8048 QEMU_OPTION_tftp,
47d5d01a 8049 QEMU_OPTION_bootp,
9d728e8c 8050 QEMU_OPTION_smb,
9bf05444 8051 QEMU_OPTION_redir,
cd6f1169
FB		 8052
8053 QEMU_OPTION_kernel,
8054 QEMU_OPTION_append,
8055 QEMU_OPTION_initrd,
8056
8057 QEMU_OPTION_S,
8058 QEMU_OPTION_s,
8059 QEMU_OPTION_p,
8060 QEMU_OPTION_d,
8061 QEMU_OPTION_hdachs,
8062 QEMU_OPTION_L,
1192dad8 8063 QEMU_OPTION_bios,
3d11d0eb 8064 QEMU_OPTION_k,
ee22c2f7 8065 QEMU_OPTION_localtime,
e9b137c2 8066 QEMU_OPTION_g,
3893c124 8067 QEMU_OPTION_vga,
20d8a3ed 8068 QEMU_OPTION_echr,
82c643ff
FB		 8069 QEMU_OPTION_monitor,
8070 QEMU_OPTION_serial,
6508fe59 8071 QEMU_OPTION_parallel,
d63d307f
FB		 8072 QEMU_OPTION_loadvm,
8073 QEMU_OPTION_full_screen,
43523e93 8074 QEMU_OPTION_no_frame,
3780e197 8075 QEMU_OPTION_alt_grab,
667accab 8076 QEMU_OPTION_no_quit,
f7cce898 8077 QEMU_OPTION_pidfile,
d993e026 8078 QEMU_OPTION_no_kqemu,
89bfc105 8079 QEMU_OPTION_kernel_kqemu,
a09db21f 8080 QEMU_OPTION_win2k_hack,
bb36d470 8081 QEMU_OPTION_usb,
a594cfbf 8082 QEMU_OPTION_usbdevice,
6a00d601 8083 QEMU_OPTION_smp,
24236869 8084 QEMU_OPTION_vnc,
6515b203 8085 QEMU_OPTION_no_acpi,
4d3b6f6e 8086 QEMU_OPTION_curses,
d1beab82 8087 QEMU_OPTION_no_reboot,
b2f76161 8088 QEMU_OPTION_no_shutdown,
9467cd46 8089 QEMU_OPTION_show_cursor,
71e3ceb8 8090 QEMU_OPTION_daemonize,
9ae02555 8091 QEMU_OPTION_option_rom,
c35734b2
TS		 8092 QEMU_OPTION_semihosting,
8093 QEMU_OPTION_name,
66508601 8094 QEMU_OPTION_prom_env,
2b8f2d41 8095 QEMU_OPTION_old_param,
f3dcfada 8096 QEMU_OPTION_clock,
7e0af5d0 8097 QEMU_OPTION_startdate,
26a5f13b 8098 QEMU_OPTION_tb_size,
2e70f6ef 8099 QEMU_OPTION_icount,
8fcb1b90 8100 QEMU_OPTION_uuid,
cd6f1169
FB		 8101};
8102
8103typedef struct QEMUOption {
8104 const char *name;
8105 int flags;
8106 int index;
8107} QEMUOption;
8108
8109const QEMUOption qemu_options[] = {
8110 { "h", 0, QEMU_OPTION_h },
64423fb2 8111 { "help", 0, QEMU_OPTION_h },
cd6f1169 8112
cc1daa40 8113 { "M", HAS_ARG, QEMU_OPTION_M },
94fc95cd 8114 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
cd6f1169
FB		 8115 { "fda", HAS_ARG, QEMU_OPTION_fda },
8116 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
8117 { "hda", HAS_ARG, QEMU_OPTION_hda },
8118 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
8119 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
8120 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
e4bcb14c 8121 { "drive", HAS_ARG, QEMU_OPTION_drive },
cd6f1169 8122 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
3e3d5815 8123 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
a1bb27b1 8124 { "sd", HAS_ARG, QEMU_OPTION_sd },
86f55663 8125 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
cd6f1169
FB		 8126 { "boot", HAS_ARG, QEMU_OPTION_boot },
8127 { "snapshot", 0, QEMU_OPTION_snapshot },
52ca8d6a
FB		 8128#ifdef TARGET_I386
8129 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
8130#endif
cd6f1169
FB		 8131 { "m", HAS_ARG, QEMU_OPTION_m },
8132 { "nographic", 0, QEMU_OPTION_nographic },
a171fe39 8133 { "portrait", 0, QEMU_OPTION_portrait },
3d11d0eb 8134 { "k", HAS_ARG, QEMU_OPTION_k },
1d14ffa9 8135#ifdef HAS_AUDIO
1d14ffa9
FB		 8136 { "audio-help", 0, QEMU_OPTION_audio_help },
8137 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
8138#endif
cd6f1169 8139
7c9d8e07 8140 { "net", HAS_ARG, QEMU_OPTION_net},
158156d1 8141#ifdef CONFIG_SLIRP
c7f74643 8142 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
47d5d01a 8143 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
c94c8d64 8144#ifndef _WIN32
9d728e8c 8145 { "smb", HAS_ARG, QEMU_OPTION_smb },
c94c8d64 8146#endif
9bf05444 8147 { "redir", HAS_ARG, QEMU_OPTION_redir },
158156d1 8148#endif
cd6f1169
FB		 8149
8150 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
8151 { "append", HAS_ARG, QEMU_OPTION_append },
8152 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
8153
8154 { "S", 0, QEMU_OPTION_S },
8155 { "s", 0, QEMU_OPTION_s },
8156 { "p", HAS_ARG, QEMU_OPTION_p },
8157 { "d", HAS_ARG, QEMU_OPTION_d },
8158 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
8159 { "L", HAS_ARG, QEMU_OPTION_L },
1192dad8 8160 { "bios", HAS_ARG, QEMU_OPTION_bios },
d993e026
FB		 8161#ifdef USE_KQEMU
8162 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
89bfc105 8163 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
d993e026 8164#endif
6f7e9aec 8165#if defined(TARGET_PPC) || defined(TARGET_SPARC)
e9b137c2 8166 { "g", 1, QEMU_OPTION_g },
77d4bc34 8167#endif
ee22c2f7 8168 { "localtime", 0, QEMU_OPTION_localtime },
3893c124 8169 { "vga", HAS_ARG, QEMU_OPTION_vga },
8b6e0729
AZ		 8170 { "echr", HAS_ARG, QEMU_OPTION_echr },
8171 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
8172 { "serial", HAS_ARG, QEMU_OPTION_serial },
8173 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
d63d307f
FB		 8174 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
8175 { "full-screen", 0, QEMU_OPTION_full_screen },
667accab 8176#ifdef CONFIG_SDL
43523e93 8177 { "no-frame", 0, QEMU_OPTION_no_frame },
3780e197 8178 { "alt-grab", 0, QEMU_OPTION_alt_grab },
667accab
TS		 8179 { "no-quit", 0, QEMU_OPTION_no_quit },
8180#endif
f7cce898 8181 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
a09db21f 8182 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
a594cfbf 8183 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6a00d601 8184 { "smp", HAS_ARG, QEMU_OPTION_smp },
24236869 8185 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4d3b6f6e
AZ		 8186#ifdef CONFIG_CURSES
8187 { "curses", 0, QEMU_OPTION_curses },
8188#endif
8fcb1b90 8189 { "uuid", HAS_ARG, QEMU_OPTION_uuid },
96d30e48 8190
1f04275e 8191 /* temporary options */
a594cfbf 8192 { "usb", 0, QEMU_OPTION_usb },
6515b203 8193 { "no-acpi", 0, QEMU_OPTION_no_acpi },
d1beab82 8194 { "no-reboot", 0, QEMU_OPTION_no_reboot },
b2f76161 8195 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
9467cd46 8196 { "show-cursor", 0, QEMU_OPTION_show_cursor },
71e3ceb8 8197 { "daemonize", 0, QEMU_OPTION_daemonize },
9ae02555 8198 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
a87295e8 8199#if defined(TARGET_ARM) || defined(TARGET_M68K)
8e71621f
PB		 8200 { "semihosting", 0, QEMU_OPTION_semihosting },
8201#endif
c35734b2 8202 { "name", HAS_ARG, QEMU_OPTION_name },
66508601
BS		 8203#if defined(TARGET_SPARC)
8204 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
2b8f2d41
AZ		 8205#endif
8206#if defined(TARGET_ARM)
8207 { "old-param", 0, QEMU_OPTION_old_param },
66508601 8208#endif
f3dcfada 8209 { "clock", HAS_ARG, QEMU_OPTION_clock },
7e0af5d0 8210 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
26a5f13b 8211 { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
2e70f6ef 8212 { "icount", HAS_ARG, QEMU_OPTION_icount },
cd6f1169 8213 { NULL },
fc01f7e7
FB		 8214};
8215
5905b2e5
FB		 8216/* password input */
8217
2bac6019
AZ		 8218int qemu_key_check(BlockDriverState *bs, const char *name)
8219{
8220 char password[256];
8221 int i;
8222
8223 if (!bdrv_is_encrypted(bs))
8224 return 0;
8225
8226 term_printf("%s is encrypted.\n", name);
8227 for(i = 0; i < 3; i++) {
8228 monitor_readline("Password: ", 1, password, sizeof(password));
8229 if (bdrv_set_key(bs, password) == 0)
8230 return 0;
8231 term_printf("invalid password\n");
8232 }
8233 return -EPERM;
8234}
8235
83ab7950
AL		 8236static BlockDriverState *get_bdrv(int index)
8237{
8238 if (index > nb_drives)
8239 return NULL;
8240 return drives_table[index].bdrv;
8241}
8242
5905b2e5
FB		 8243static void read_passwords(void)
8244{
8245 BlockDriverState *bs;
2bac6019 8246 int i;
5905b2e5 8247
83ab7950
AL		 8248 for(i = 0; i < 6; i++) {
8249 bs = get_bdrv(i);
8250 if (bs)
8251 qemu_key_check(bs, bdrv_get_device_name(bs));
5905b2e5
FB		 8252 }
8253}
8254
1d14ffa9 8255#ifdef HAS_AUDIO
6a36d84e 8256struct soundhw soundhw[] = {
b00052e4 8257#ifdef HAS_AUDIO_CHOICE
4ce7ff6e 8258#if defined(TARGET_I386) || defined(TARGET_MIPS)
fd06c375
FB		 8259 {
8260 "pcspk",
8261 "PC speaker",
8262 0,
8263 1,
8264 { .init_isa = pcspk_audio_init }
8265 },
8266#endif
6a36d84e
FB		 8267 {
8268 "sb16",
8269 "Creative Sound Blaster 16",
8270 0,
8271 1,
8272 { .init_isa = SB16_init }
8273 },
8274
cc53d26d 8275#ifdef CONFIG_CS4231A
8276 {
8277 "cs4231a",
8278 "CS4231A",
8279 0,
8280 1,
8281 { .init_isa = cs4231a_init }
8282 },
8283#endif
8284
1d14ffa9 8285#ifdef CONFIG_ADLIB
6a36d84e
FB		 8286 {
8287 "adlib",
1d14ffa9 8288#ifdef HAS_YMF262
6a36d84e 8289 "Yamaha YMF262 (OPL3)",
1d14ffa9 8290#else
6a36d84e 8291 "Yamaha YM3812 (OPL2)",
1d14ffa9 8292#endif
6a36d84e
FB		 8293 0,
8294 1,
8295 { .init_isa = Adlib_init }
8296 },
1d14ffa9 8297#endif
6a36d84e 8298
1d14ffa9 8299#ifdef CONFIG_GUS
6a36d84e
FB		 8300 {
8301 "gus",
8302 "Gravis Ultrasound GF1",
8303 0,
8304 1,
8305 { .init_isa = GUS_init }
8306 },
1d14ffa9 8307#endif
6a36d84e 8308
e5c9a13e
AZ		 8309#ifdef CONFIG_AC97
8310 {
8311 "ac97",
8312 "Intel 82801AA AC97 Audio",
8313 0,
8314 0,
8315 { .init_pci = ac97_init }
8316 },
8317#endif
8318
6a36d84e
FB		 8319 {
8320 "es1370",
8321 "ENSONIQ AudioPCI ES1370",
8322 0,
8323 0,
8324 { .init_pci = es1370_init }
8325 },
b00052e4 8326#endif
6a36d84e
FB		 8327
8328 { NULL, NULL, 0, 0, { NULL } }
8329};
8330
8331static void select_soundhw (const char *optarg)
8332{
8333 struct soundhw *c;
8334
8335 if (*optarg == '?') {
8336 show_valid_cards:
8337
8338 printf ("Valid sound card names (comma separated):\n");
8339 for (c = soundhw; c->name; ++c) {
8340 printf ("%-11s %s\n", c->name, c->descr);
8341 }
8342 printf ("\n-soundhw all will enable all of the above\n");
1d14ffa9
FB		 8343 exit (*optarg != '?');
8344 }
8345 else {
6a36d84e 8346 size_t l;
1d14ffa9
FB		 8347 const char *p;
8348 char *e;
8349 int bad_card = 0;
8350
6a36d84e
FB		 8351 if (!strcmp (optarg, "all")) {
8352 for (c = soundhw; c->name; ++c) {
8353 c->enabled = 1;
8354 }
8355 return;
8356 }
1d14ffa9 8357
6a36d84e 8358 p = optarg;
1d14ffa9
FB		 8359 while (*p) {
8360 e = strchr (p, ',');
8361 l = !e ? strlen (p) : (size_t) (e - p);
6a36d84e
FB		 8362
8363 for (c = soundhw; c->name; ++c) {
8364 if (!strncmp (c->name, p, l)) {
8365 c->enabled = 1;
1d14ffa9
FB		 8366 break;
8367 }
8368 }
6a36d84e
FB		 8369
8370 if (!c->name) {
1d14ffa9
FB		 8371 if (l > 80) {
8372 fprintf (stderr,
8373 "Unknown sound card name (too big to show)\n");
8374 }
8375 else {
8376 fprintf (stderr, "Unknown sound card name `%.*s'\n",
8377 (int) l, p);
8378 }
8379 bad_card = 1;
8380 }
8381 p += l + (e != NULL);
8382 }
8383
8384 if (bad_card)
8385 goto show_valid_cards;
8386 }
8387}
8388#endif
8389
3893c124 8390static void select_vgahw (const char *p)
8391{
8392 const char *opts;
8393
8394 if (strstart(p, "std", &opts)) {
8395 cirrus_vga_enabled = 0;
8396 vmsvga_enabled = 0;
8397 } else if (strstart(p, "cirrus", &opts)) {
8398 cirrus_vga_enabled = 1;
8399 vmsvga_enabled = 0;
8400 } else if (strstart(p, "vmware", &opts)) {
8401 cirrus_vga_enabled = 0;
8402 vmsvga_enabled = 1;
8403 } else {
8404 invalid_vga:
8405 fprintf(stderr, "Unknown vga type: %s\n", p);
8406 exit(1);
8407 }
cb5a7aa8 8408 while (*opts) {
8409 const char *nextopt;
8410
8411 if (strstart(opts, ",retrace=", &nextopt)) {
8412 opts = nextopt;
8413 if (strstart(opts, "dumb", &nextopt))
8414 vga_retrace_method = VGA_RETRACE_DUMB;
8415 else if (strstart(opts, "precise", &nextopt))
8416 vga_retrace_method = VGA_RETRACE_PRECISE;
8417 else goto invalid_vga;
8418 } else goto invalid_vga;
8419 opts = nextopt;
8420 }
3893c124 8421}
8422
3587d7e6
FB		 8423#ifdef _WIN32
8424static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8425{
8426 exit(STATUS_CONTROL_C_EXIT);
8427 return TRUE;
8428}
8429#endif
8430
8fcb1b90
BS		 8431static int qemu_uuid_parse(const char *str, uint8_t *uuid)
8432{
8433 int ret;
8434
8435 if(strlen(str) != 36)
8436 return -1;
8437
8438 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
8439 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
8440 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
8441
8442 if(ret != 16)
8443 return -1;
8444
8445 return 0;
8446}
8447
7c9d8e07 8448#define MAX_NET_CLIENTS 32
c20709aa 8449
5b08fc10
AL		 8450#ifndef _WIN32
8451
8452static void termsig_handler(int signal)
8453{
8454 qemu_system_shutdown_request();
8455}
8456
6f9e3801 8457static void termsig_setup(void)
5b08fc10
AL		 8458{
8459 struct sigaction act;
8460
8461 memset(&act, 0, sizeof(act));
8462 act.sa_handler = termsig_handler;
8463 sigaction(SIGINT, &act, NULL);
8464 sigaction(SIGHUP, &act, NULL);
8465 sigaction(SIGTERM, &act, NULL);
8466}
8467
8468#endif
8469
0824d6fc
FB		 8470int main(int argc, char **argv)
8471{
67b915a5 8472#ifdef CONFIG_GDBSTUB
cfc3475a
PB		 8473 int use_gdbstub;
8474 const char *gdbstub_port;
67b915a5 8475#endif
28c5af54 8476 uint32_t boot_devices_bitmap = 0;
e4bcb14c 8477 int i;
28c5af54 8478 int snapshot, linux_boot, net_boot;
7f7f9873 8479 const char *initrd_filename;
a20dd508 8480 const char *kernel_filename, *kernel_cmdline;
28c5af54 8481 const char *boot_devices = "";
313aa567 8482 DisplayState *ds = &display_state;
46d4767d 8483 int cyls, heads, secs, translation;
fd5f393a 8484 const char *net_clients[MAX_NET_CLIENTS];
7c9d8e07 8485 int nb_net_clients;
e4bcb14c 8486 int hda_index;
cd6f1169
FB		 8487 int optind;
8488 const char *r, *optarg;
82c643ff 8489 CharDriverState *monitor_hd;
fd5f393a
PB		 8490 const char *monitor_device;
8491 const char *serial_devices[MAX_SERIAL_PORTS];
8d11df9e 8492 int serial_device_index;
fd5f393a 8493 const char *parallel_devices[MAX_PARALLEL_PORTS];
6508fe59 8494 int parallel_device_index;
d63d307f 8495 const char *loadvm = NULL;
cc1daa40 8496 QEMUMachine *machine;
94fc95cd 8497 const char *cpu_model;
fd5f393a 8498 const char *usb_devices[MAX_USB_CMDLINE];
a594cfbf 8499 int usb_devices_index;
71e3ceb8 8500 int fds[2];
26a5f13b 8501 int tb_size;
93815bc2 8502 const char *pid_file = NULL;
833c7174 8503 VLANState *vlan;
0bd48850
FB		 8504
8505 LIST_INIT (&vm_change_state_head);
be995c27
FB		 8506#ifndef _WIN32
8507 {
8508 struct sigaction act;
8509 sigfillset(&act.sa_mask);
8510 act.sa_flags = 0;
8511 act.sa_handler = SIG_IGN;
8512 sigaction(SIGPIPE, &act, NULL);
8513 }
3587d7e6
FB		 8514#else
8515 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
a8e5ac33
FB		 8516 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8517 QEMU to run on a single CPU */
8518 {
8519 HANDLE h;
8520 DWORD mask, smask;
8521 int i;
8522 h = GetCurrentProcess();
8523 if (GetProcessAffinityMask(h, &mask, &smask)) {
8524 for(i = 0; i < 32; i++) {
8525 if (mask & (1 << i))
8526 break;
8527 }
8528 if (i != 32) {
8529 mask = 1 << i;
8530 SetProcessAffinityMask(h, mask);
8531 }
8532 }
8533 }
67b915a5 8534#endif
be995c27 8535
cc1daa40
FB		 8536 register_machines();
8537 machine = first_machine;
94fc95cd 8538 cpu_model = NULL;
fc01f7e7 8539 initrd_filename = NULL;
4fc5d071 8540 ram_size = 0;
313aa567 8541 vga_ram_size = VGA_RAM_SIZE;
67b915a5 8542#ifdef CONFIG_GDBSTUB
b4608c04 8543 use_gdbstub = 0;
c636bb66 8544 gdbstub_port = DEFAULT_GDBSTUB_PORT;
67b915a5 8545#endif
33e3963e 8546 snapshot = 0;
a20dd508 8547 nographic = 0;
4d3b6f6e 8548 curses = 0;
a20dd508
FB		 8549 kernel_filename = NULL;
8550 kernel_cmdline = "";
c4b1fcc0 8551 cyls = heads = secs = 0;
46d4767d 8552 translation = BIOS_ATA_TRANSLATION_AUTO;
c60e08d9 8553 monitor_device = "vc";
c4b1fcc0 8554
c75a823c 8555 serial_devices[0] = "vc:80Cx24C";
8d11df9e 8556 for(i = 1; i < MAX_SERIAL_PORTS; i++)
fd5f393a 8557 serial_devices[i] = NULL;
8d11df9e 8558 serial_device_index = 0;
3b46e624 8559
c75a823c 8560 parallel_devices[0] = "vc:640x480";
6508fe59 8561 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
fd5f393a 8562 parallel_devices[i] = NULL;
6508fe59 8563 parallel_device_index = 0;
3b46e624 8564
a594cfbf 8565 usb_devices_index = 0;
3b46e624 8566
7c9d8e07 8567 nb_net_clients = 0;
e4bcb14c
TS		 8568 nb_drives = 0;
8569 nb_drives_opt = 0;
8570 hda_index = -1;
7c9d8e07
FB		 8571
8572 nb_nics = 0;
3b46e624 8573
26a5f13b
FB		 8574 tb_size = 0;
8575
cd6f1169 8576 optind = 1;
0824d6fc 8577 for(;;) {
cd6f1169 8578 if (optind >= argc)
0824d6fc 8579 break;
cd6f1169
FB		 8580 r = argv[optind];
8581 if (r[0] != '-') {
609497ab 8582 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
cd6f1169
FB		 8583 } else {
8584 const QEMUOption *popt;
8585
8586 optind++;
dff5efc8
PB		 8587 /* Treat --foo the same as -foo. */
8588 if (r[1] == '-')
8589 r++;
cd6f1169
FB		 8590 popt = qemu_options;
8591 for(;;) {
8592 if (!popt->name) {
5fafdf24 8593 fprintf(stderr, "%s: invalid option -- '%s'\n",
cd6f1169
FB		 8594 argv[0], r);
8595 exit(1);
8596 }
8597 if (!strcmp(popt->name, r + 1))
8598 break;
8599 popt++;
8600 }
8601 if (popt->flags & HAS_ARG) {
8602 if (optind >= argc) {
8603 fprintf(stderr, "%s: option '%s' requires an argument\n",
8604 argv[0], r);
8605 exit(1);
8606 }
8607 optarg = argv[optind++];
8608 } else {
8609 optarg = NULL;
8610 }
8611
8612 switch(popt->index) {
cc1daa40
FB		 8613 case QEMU_OPTION_M:
8614 machine = find_machine(optarg);
8615 if (!machine) {
8616 QEMUMachine *m;
8617 printf("Supported machines are:\n");
8618 for(m = first_machine; m != NULL; m = m->next) {
8619 printf("%-10s %s%s\n",
5fafdf24 8620 m->name, m->desc,
cc1daa40
FB		 8621 m == first_machine ? " (default)" : "");
8622 }
15f82208 8623 exit(*optarg != '?');
cc1daa40
FB		 8624 }
8625 break;
94fc95cd
JM		 8626 case QEMU_OPTION_cpu:
8627 /* hw initialization will check this */
15f82208 8628 if (*optarg == '?') {
c732abe2
JM		 8629/* XXX: implement xxx_cpu_list for targets that still miss it */
8630#if defined(cpu_list)
8631 cpu_list(stdout, &fprintf);
94fc95cd 8632#endif
15f82208 8633 exit(0);
94fc95cd
JM		 8634 } else {
8635 cpu_model = optarg;
8636 }
8637 break;
cd6f1169 8638 case QEMU_OPTION_initrd:
fc01f7e7
FB		 8639 initrd_filename = optarg;
8640 break;
cd6f1169 8641 case QEMU_OPTION_hda:
e4bcb14c 8642 if (cyls == 0)
609497ab 8643 hda_index = drive_add(optarg, HD_ALIAS, 0);
e4bcb14c 8644 else
609497ab 8645 hda_index = drive_add(optarg, HD_ALIAS
e4bcb14c 8646 ",cyls=%d,heads=%d,secs=%d%s",
609497ab 8647 0, cyls, heads, secs,
e4bcb14c
TS		 8648 translation == BIOS_ATA_TRANSLATION_LBA ?
8649 ",trans=lba" :
8650 translation == BIOS_ATA_TRANSLATION_NONE ?
8651 ",trans=none" : "");
8652 break;
cd6f1169 8653 case QEMU_OPTION_hdb:
cc1daa40
FB		 8654 case QEMU_OPTION_hdc:
8655 case QEMU_OPTION_hdd:
609497ab 8656 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
fc01f7e7 8657 break;
e4bcb14c 8658 case QEMU_OPTION_drive:
609497ab 8659 drive_add(NULL, "%s", optarg);
e4bcb14c 8660 break;
3e3d5815 8661 case QEMU_OPTION_mtdblock:
609497ab 8662 drive_add(optarg, MTD_ALIAS);
3e3d5815 8663 break;
a1bb27b1 8664 case QEMU_OPTION_sd:
609497ab 8665 drive_add(optarg, SD_ALIAS);
a1bb27b1 8666 break;
86f55663 8667 case QEMU_OPTION_pflash:
609497ab 8668 drive_add(optarg, PFLASH_ALIAS);
86f55663 8669 break;
cd6f1169 8670 case QEMU_OPTION_snapshot:
33e3963e
FB		 8671 snapshot = 1;
8672 break;
cd6f1169 8673 case QEMU_OPTION_hdachs:
330d0414 8674 {
330d0414
FB		 8675 const char *p;
8676 p = optarg;
8677 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 8678 if (cyls < 1 || cyls > 16383)
8679 goto chs_fail;
330d0414
FB		 8680 if (*p != ',')
8681 goto chs_fail;
8682 p++;
8683 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 8684 if (heads < 1 || heads > 16)
8685 goto chs_fail;
330d0414
FB		 8686 if (*p != ',')
8687 goto chs_fail;
8688 p++;
8689 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 8690 if (secs < 1 || secs > 63)
8691 goto chs_fail;
8692 if (*p == ',') {
8693 p++;
8694 if (!strcmp(p, "none"))
8695 translation = BIOS_ATA_TRANSLATION_NONE;
8696 else if (!strcmp(p, "lba"))
8697 translation = BIOS_ATA_TRANSLATION_LBA;
8698 else if (!strcmp(p, "auto"))
8699 translation = BIOS_ATA_TRANSLATION_AUTO;
8700 else
8701 goto chs_fail;
8702 } else if (*p != '\0') {
c4b1fcc0 8703 chs_fail:
46d4767d
FB		 8704 fprintf(stderr, "qemu: invalid physical CHS format\n");
8705 exit(1);
c4b1fcc0 8706 }
e4bcb14c 8707 if (hda_index != -1)
609497ab
AZ		 8708 snprintf(drives_opt[hda_index].opt,
8709 sizeof(drives_opt[hda_index].opt),
8710 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8711 0, cyls, heads, secs,
e4bcb14c
TS		 8712 translation == BIOS_ATA_TRANSLATION_LBA ?
8713 ",trans=lba" :
8714 translation == BIOS_ATA_TRANSLATION_NONE ?
8715 ",trans=none" : "");
330d0414
FB		 8716 }
8717 break;
cd6f1169 8718 case QEMU_OPTION_nographic:
a20dd508
FB		 8719 nographic = 1;
8720 break;
4d3b6f6e
AZ		 8721#ifdef CONFIG_CURSES
8722 case QEMU_OPTION_curses:
8723 curses = 1;
8724 break;
8725#endif
a171fe39
AZ		 8726 case QEMU_OPTION_portrait:
8727 graphic_rotate = 1;
8728 break;
cd6f1169 8729 case QEMU_OPTION_kernel:
a20dd508
FB		 8730 kernel_filename = optarg;
8731 break;
cd6f1169 8732 case QEMU_OPTION_append:
a20dd508 8733 kernel_cmdline = optarg;
313aa567 8734 break;
cd6f1169 8735 case QEMU_OPTION_cdrom:
609497ab 8736 drive_add(optarg, CDROM_ALIAS);
36b486bb 8737 break;
cd6f1169 8738 case QEMU_OPTION_boot:
28c5af54
JM		 8739 boot_devices = optarg;
8740 /* We just do some generic consistency checks */
8741 {
8742 /* Could easily be extended to 64 devices if needed */
60fe76f3 8743 const char *p;
28c5af54
JM		 8744
8745 boot_devices_bitmap = 0;
8746 for (p = boot_devices; *p != '\0'; p++) {
8747 /* Allowed boot devices are:
8748 * a b : floppy disk drives
8749 * c ... f : IDE disk drives
8750 * g ... m : machine implementation dependant drives
8751 * n ... p : network devices
8752 * It's up to each machine implementation to check
8753 * if the given boot devices match the actual hardware
8754 * implementation and firmware features.
8755 */
8756 if (*p < 'a' || *p > 'q') {
8757 fprintf(stderr, "Invalid boot device '%c'\n", *p);
8758 exit(1);
8759 }
8760 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8761 fprintf(stderr,
8762 "Boot device '%c' was given twice\n",*p);
8763 exit(1);
8764 }
8765 boot_devices_bitmap |= 1 << (*p - 'a');
8766 }
36b486bb
FB		 8767 }
8768 break;
cd6f1169 8769 case QEMU_OPTION_fda:
cd6f1169 8770 case QEMU_OPTION_fdb:
609497ab 8771 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
c45886db 8772 break;
52ca8d6a
FB		 8773#ifdef TARGET_I386
8774 case QEMU_OPTION_no_fd_bootchk:
8775 fd_bootchk = 0;
8776 break;
8777#endif
7c9d8e07
FB		 8778 case QEMU_OPTION_net:
8779 if (nb_net_clients >= MAX_NET_CLIENTS) {
8780 fprintf(stderr, "qemu: too many network clients\n");
c4b1fcc0
FB		 8781 exit(1);
8782 }
fd5f393a 8783 net_clients[nb_net_clients] = optarg;
7c9d8e07 8784 nb_net_clients++;
702c651c 8785 break;
c7f74643
FB		 8786#ifdef CONFIG_SLIRP
8787 case QEMU_OPTION_tftp:
c7f74643 8788 tftp_prefix = optarg;
9bf05444 8789 break;
47d5d01a
TS		 8790 case QEMU_OPTION_bootp:
8791 bootp_filename = optarg;
8792 break;
c94c8d64 8793#ifndef _WIN32
9d728e8c
FB		 8794 case QEMU_OPTION_smb:
8795 net_slirp_smb(optarg);
8796 break;
c94c8d64 8797#endif
9bf05444 8798 case QEMU_OPTION_redir:
3b46e624 8799 net_slirp_redir(optarg);
9bf05444 8800 break;
c7f74643 8801#endif
1d14ffa9 8802#ifdef HAS_AUDIO
1d14ffa9
FB		 8803 case QEMU_OPTION_audio_help:
8804 AUD_help ();
8805 exit (0);
8806 break;
8807 case QEMU_OPTION_soundhw:
8808 select_soundhw (optarg);
8809 break;
8810#endif
cd6f1169 8811 case QEMU_OPTION_h:
15f82208 8812 help(0);
cd6f1169 8813 break;
00f82b8a
AJ		 8814 case QEMU_OPTION_m: {
8815 uint64_t value;
8816 char *ptr;
8817
8818 value = strtoul(optarg, &ptr, 10);
8819 switch (*ptr) {
8820 case 0: case 'M': case 'm':
8821 value <<= 20;
8822 break;
8823 case 'G': case 'g':
8824 value <<= 30;
8825 break;
8826 default:
8827 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
cd6f1169
FB		 8828 exit(1);
8829 }
00f82b8a
AJ		 8830
8831 /* On 32-bit hosts, QEMU is limited by virtual address space */
8832 if (value > (2047 << 20)
8833#ifndef USE_KQEMU
8834 && HOST_LONG_BITS == 32
8835#endif
8836 ) {
8837 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
8838 exit(1);
8839 }
8840 if (value != (uint64_t)(ram_addr_t)value) {
8841 fprintf(stderr, "qemu: ram size too large\n");
8842 exit(1);
8843 }
8844 ram_size = value;
cd6f1169 8845 break;
00f82b8a 8846 }
cd6f1169
FB		 8847 case QEMU_OPTION_d:
8848 {
8849 int mask;
8850 CPULogItem *item;
3b46e624 8851
cd6f1169
FB		 8852 mask = cpu_str_to_log_mask(optarg);
8853 if (!mask) {
8854 printf("Log items (comma separated):\n");
f193c797
FB		 8855 for(item = cpu_log_items; item->mask != 0; item++) {
8856 printf("%-10s %s\n", item->name, item->help);
8857 }
8858 exit(1);
cd6f1169
FB		 8859 }
8860 cpu_set_log(mask);
f193c797 8861 }
cd6f1169 8862 break;
67b915a5 8863#ifdef CONFIG_GDBSTUB
cd6f1169
FB		 8864 case QEMU_OPTION_s:
8865 use_gdbstub = 1;
8866 break;
8867 case QEMU_OPTION_p:
cfc3475a 8868 gdbstub_port = optarg;
cd6f1169 8869 break;
67b915a5 8870#endif
cd6f1169
FB		 8871 case QEMU_OPTION_L:
8872 bios_dir = optarg;
8873 break;
1192dad8
JM		 8874 case QEMU_OPTION_bios:
8875 bios_name = optarg;
8876 break;
cd6f1169 8877 case QEMU_OPTION_S:
3c07f8e8 8878 autostart = 0;
cd6f1169 8879 break;
3d11d0eb
FB		 8880 case QEMU_OPTION_k:
8881 keyboard_layout = optarg;
8882 break;
ee22c2f7
FB		 8883 case QEMU_OPTION_localtime:
8884 rtc_utc = 0;
8885 break;
3893c124 8886 case QEMU_OPTION_vga:
8887 select_vgahw (optarg);
1bfe856e 8888 break;
e9b137c2
FB		 8889 case QEMU_OPTION_g:
8890 {
8891 const char *p;
8892 int w, h, depth;
8893 p = optarg;
8894 w = strtol(p, (char **)&p, 10);
8895 if (w <= 0) {
8896 graphic_error:
8897 fprintf(stderr, "qemu: invalid resolution or depth\n");
8898 exit(1);
8899 }
8900 if (*p != 'x')
8901 goto graphic_error;
8902 p++;
8903 h = strtol(p, (char **)&p, 10);
8904 if (h <= 0)
8905 goto graphic_error;
8906 if (*p == 'x') {
8907 p++;
8908 depth = strtol(p, (char **)&p, 10);
5fafdf24 8909 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 8910 depth != 24 && depth != 32)
8911 goto graphic_error;
8912 } else if (*p == '\0') {
8913 depth = graphic_depth;
8914 } else {
8915 goto graphic_error;
8916 }
3b46e624 8917
e9b137c2
FB		 8918 graphic_width = w;
8919 graphic_height = h;
8920 graphic_depth = depth;
8921 }
8922 break;
20d8a3ed
TS		 8923 case QEMU_OPTION_echr:
8924 {
8925 char *r;
8926 term_escape_char = strtol(optarg, &r, 0);
8927 if (r == optarg)
8928 printf("Bad argument to echr\n");
8929 break;
8930 }
82c643ff 8931 case QEMU_OPTION_monitor:
fd5f393a 8932 monitor_device = optarg;
82c643ff
FB		 8933 break;
8934 case QEMU_OPTION_serial:
8d11df9e
FB		 8935 if (serial_device_index >= MAX_SERIAL_PORTS) {
8936 fprintf(stderr, "qemu: too many serial ports\n");
8937 exit(1);
8938 }
fd5f393a 8939 serial_devices[serial_device_index] = optarg;
8d11df9e 8940 serial_device_index++;
82c643ff 8941 break;
6508fe59
FB		 8942 case QEMU_OPTION_parallel:
8943 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8944 fprintf(stderr, "qemu: too many parallel ports\n");
8945 exit(1);
8946 }
fd5f393a 8947 parallel_devices[parallel_device_index] = optarg;
6508fe59
FB		 8948 parallel_device_index++;
8949 break;
d63d307f
FB		 8950 case QEMU_OPTION_loadvm:
8951 loadvm = optarg;
8952 break;
8953 case QEMU_OPTION_full_screen:
8954 full_screen = 1;
8955 break;
667accab 8956#ifdef CONFIG_SDL
43523e93
TS		 8957 case QEMU_OPTION_no_frame:
8958 no_frame = 1;
8959 break;
3780e197
TS		 8960 case QEMU_OPTION_alt_grab:
8961 alt_grab = 1;
8962 break;
667accab
TS		 8963 case QEMU_OPTION_no_quit:
8964 no_quit = 1;
8965 break;
8966#endif
f7cce898 8967 case QEMU_OPTION_pidfile:
93815bc2 8968 pid_file = optarg;
f7cce898 8969 break;
a09db21f
FB		 8970#ifdef TARGET_I386
8971 case QEMU_OPTION_win2k_hack:
8972 win2k_install_hack = 1;
8973 break;
8974#endif
d993e026
FB		 8975#ifdef USE_KQEMU
8976 case QEMU_OPTION_no_kqemu:
8977 kqemu_allowed = 0;
8978 break;
89bfc105
FB		 8979 case QEMU_OPTION_kernel_kqemu:
8980 kqemu_allowed = 2;
8981 break;
d993e026 8982#endif
bb36d470
FB		 8983 case QEMU_OPTION_usb:
8984 usb_enabled = 1;
8985 break;
a594cfbf
FB		 8986 case QEMU_OPTION_usbdevice:
8987 usb_enabled = 1;
0d92ed30 8988 if (usb_devices_index >= MAX_USB_CMDLINE) {
a594cfbf
FB		 8989 fprintf(stderr, "Too many USB devices\n");
8990 exit(1);
8991 }
fd5f393a 8992 usb_devices[usb_devices_index] = optarg;
a594cfbf
FB		 8993 usb_devices_index++;
8994 break;
6a00d601
FB		 8995 case QEMU_OPTION_smp:
8996 smp_cpus = atoi(optarg);
ba3c64fb 8997 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
6a00d601
FB		 8998 fprintf(stderr, "Invalid number of CPUs\n");
8999 exit(1);
9000 }
9001 break;
24236869 9002 case QEMU_OPTION_vnc:
73fc9742 9003 vnc_display = optarg;
24236869 9004 break;
6515b203
FB		 9005 case QEMU_OPTION_no_acpi:
9006 acpi_enabled = 0;
9007 break;
d1beab82
FB		 9008 case QEMU_OPTION_no_reboot:
9009 no_reboot = 1;
9010 break;
b2f76161
AJ		 9011 case QEMU_OPTION_no_shutdown:
9012 no_shutdown = 1;
9013 break;
9467cd46
AZ		 9014 case QEMU_OPTION_show_cursor:
9015 cursor_hide = 0;
9016 break;
8fcb1b90
BS		 9017 case QEMU_OPTION_uuid:
9018 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
9019 fprintf(stderr, "Fail to parse UUID string."
9020 " Wrong format.\n");
9021 exit(1);
9022 }
9023 break;
71e3ceb8
TS		 9024 case QEMU_OPTION_daemonize:
9025 daemonize = 1;
9026 break;
9ae02555
TS		 9027 case QEMU_OPTION_option_rom:
9028 if (nb_option_roms >= MAX_OPTION_ROMS) {
9029 fprintf(stderr, "Too many option ROMs\n");
9030 exit(1);
9031 }
9032 option_rom[nb_option_roms] = optarg;
9033 nb_option_roms++;
9034 break;
8e71621f
PB		 9035 case QEMU_OPTION_semihosting:
9036 semihosting_enabled = 1;
9037 break;
c35734b2
TS		 9038 case QEMU_OPTION_name:
9039 qemu_name = optarg;
9040 break;
66508601
BS		 9041#ifdef TARGET_SPARC
9042 case QEMU_OPTION_prom_env:
9043 if (nb_prom_envs >= MAX_PROM_ENVS) {
9044 fprintf(stderr, "Too many prom variables\n");
9045 exit(1);
9046 }
9047 prom_envs[nb_prom_envs] = optarg;
9048 nb_prom_envs++;
9049 break;
2b8f2d41
AZ		 9050#endif
9051#ifdef TARGET_ARM
9052 case QEMU_OPTION_old_param:
9053 old_param = 1;
05ebd537 9054 break;
66508601 9055#endif
f3dcfada
TS		 9056 case QEMU_OPTION_clock:
9057 configure_alarms(optarg);
9058 break;
7e0af5d0
FB		 9059 case QEMU_OPTION_startdate:
9060 {
9061 struct tm tm;
f6503059 9062 time_t rtc_start_date;
7e0af5d0 9063 if (!strcmp(optarg, "now")) {
f6503059 9064 rtc_date_offset = -1;
7e0af5d0
FB		 9065 } else {
9066 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
9067 &tm.tm_year,
9068 &tm.tm_mon,
9069 &tm.tm_mday,
9070 &tm.tm_hour,
9071 &tm.tm_min,
9072 &tm.tm_sec) == 6) {
9073 /* OK */
9074 } else if (sscanf(optarg, "%d-%d-%d",
9075 &tm.tm_year,
9076 &tm.tm_mon,
9077 &tm.tm_mday) == 3) {
9078 tm.tm_hour = 0;
9079 tm.tm_min = 0;
9080 tm.tm_sec = 0;
9081 } else {
9082 goto date_fail;
9083 }
9084 tm.tm_year -= 1900;
9085 tm.tm_mon--;
3c6b2088 9086 rtc_start_date = mktimegm(&tm);
7e0af5d0
FB		 9087 if (rtc_start_date == -1) {
9088 date_fail:
9089 fprintf(stderr, "Invalid date format. Valid format are:\n"
9090 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9091 exit(1);
9092 }
f6503059 9093 rtc_date_offset = time(NULL) - rtc_start_date;
7e0af5d0
FB		 9094 }
9095 }
9096 break;
26a5f13b
FB		 9097 case QEMU_OPTION_tb_size:
9098 tb_size = strtol(optarg, NULL, 0);
9099 if (tb_size < 0)
9100 tb_size = 0;
9101 break;
2e70f6ef
PB		 9102 case QEMU_OPTION_icount:
9103 use_icount = 1;
9104 if (strcmp(optarg, "auto") == 0) {
9105 icount_time_shift = -1;
9106 } else {
9107 icount_time_shift = strtol(optarg, NULL, 0);
9108 }
9109 break;
cd6f1169 9110 }
0824d6fc
FB		 9111 }
9112 }
330d0414 9113
bc0129d9
AL		 9114 if (nographic) {
9115 if (serial_device_index == 0)
9116 serial_devices[0] = "stdio";
9117 if (parallel_device_index == 0)
9118 parallel_devices[0] = "null";
9119 if (strncmp(monitor_device, "vc", 2) == 0)
9120 monitor_device = "stdio";
9121 }
9122
71e3ceb8 9123#ifndef _WIN32
71e3ceb8
TS		 9124 if (daemonize) {
9125 pid_t pid;
9126
9127 if (pipe(fds) == -1)
9128 exit(1);
9129
9130 pid = fork();
9131 if (pid > 0) {
9132 uint8_t status;
9133 ssize_t len;
9134
9135 close(fds[1]);
9136
9137 again:
93815bc2
TS		 9138 len = read(fds[0], &status, 1);
9139 if (len == -1 && (errno == EINTR))
9140 goto again;
9141
9142 if (len != 1)
9143 exit(1);
9144 else if (status == 1) {
9145 fprintf(stderr, "Could not acquire pidfile\n");
9146 exit(1);
9147 } else
9148 exit(0);
71e3ceb8 9149 } else if (pid < 0)
93815bc2 9150 exit(1);
71e3ceb8
TS		 9151
9152 setsid();
9153
9154 pid = fork();
9155 if (pid > 0)
9156 exit(0);
9157 else if (pid < 0)
9158 exit(1);
9159
9160 umask(027);
71e3ceb8
TS		 9161
9162 signal(SIGTSTP, SIG_IGN);
9163 signal(SIGTTOU, SIG_IGN);
9164 signal(SIGTTIN, SIG_IGN);
9165 }
9166#endif
9167
aa26bb2d 9168 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
93815bc2
TS		 9169 if (daemonize) {
9170 uint8_t status = 1;
9171 write(fds[1], &status, 1);
9172 } else
9173 fprintf(stderr, "Could not acquire pid file\n");
9174 exit(1);
9175 }
9176
ff3fbb30
FB		 9177#ifdef USE_KQEMU
9178 if (smp_cpus > 1)
9179 kqemu_allowed = 0;
9180#endif
a20dd508 9181 linux_boot = (kernel_filename != NULL);
7317b8ca 9182 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
6c41b272 9183
28c5af54 9184 if (!linux_boot && net_boot == 0 &&
f88e4b91 9185 !machine->nodisk_ok && nb_drives_opt == 0)
15f82208 9186 help(1);
0824d6fc 9187
f8d39c01
TS		 9188 if (!linux_boot && *kernel_cmdline != '\0') {
9189 fprintf(stderr, "-append only allowed with -kernel option\n");
9190 exit(1);
9191 }
9192
9193 if (!linux_boot && initrd_filename != NULL) {
9194 fprintf(stderr, "-initrd only allowed with -kernel option\n");
9195 exit(1);
9196 }
9197
96d30e48 9198 /* boot to floppy or the default cd if no hard disk defined yet */
28c5af54 9199 if (!boot_devices[0]) {
e4bcb14c 9200 boot_devices = "cad";
96d30e48 9201 }
b118d61e 9202 setvbuf(stdout, NULL, _IOLBF, 0);
3b46e624 9203
634fce96
PB		 9204 init_timers();
9205 init_timer_alarm();
2e70f6ef
PB		 9206 if (use_icount && icount_time_shift < 0) {
9207 use_icount = 2;
9208 /* 125MIPS seems a reasonable initial guess at the guest speed.
9209 It will be corrected fairly quickly anyway. */
9210 icount_time_shift = 3;
9211 init_icount_adjust();
9212 }
634fce96 9213
fd1dff4b
FB		 9214#ifdef _WIN32
9215 socket_init();
9216#endif
9217
7c9d8e07
FB		 9218 /* init network clients */
9219 if (nb_net_clients == 0) {
9220 /* if no clients, we use a default config */
f441b28b
AL		 9221 net_clients[nb_net_clients++] = "nic";
9222#ifdef CONFIG_SLIRP
9223 net_clients[nb_net_clients++] = "user";
9224#endif
c20709aa
FB		 9225 }
9226
7c9d8e07 9227 for(i = 0;i < nb_net_clients; i++) {
9ad97e65 9228 if (net_client_parse(net_clients[i]) < 0)
7c9d8e07 9229 exit(1);
702c651c 9230 }
833c7174
BS		 9231 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9232 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
9233 continue;
9ad97e65
AZ		 9234 if (vlan->nb_guest_devs == 0)
9235 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
833c7174
BS		 9236 if (vlan->nb_host_devs == 0)
9237 fprintf(stderr,
9238 "Warning: vlan %d is not connected to host network\n",
9239 vlan->id);
9240 }
f1510b2c 9241
eec85c2a 9242#ifdef TARGET_I386
ed494d87 9243 /* XXX: this should be moved in the PC machine instantiation code */
28c5af54
JM		 9244 if (net_boot != 0) {
9245 int netroms = 0;
9246 for (i = 0; i < nb_nics && i < 4; i++) {
eec85c2a
TS		 9247 const char *model = nd_table[i].model;
9248 char buf[1024];
28c5af54
JM		 9249 if (net_boot & (1 << i)) {
9250 if (model == NULL)
9251 model = "ne2k_pci";
9252 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
9253 if (get_image_size(buf) > 0) {
9254 if (nb_option_roms >= MAX_OPTION_ROMS) {
9255 fprintf(stderr, "Too many option ROMs\n");
9256 exit(1);
9257 }
9258 option_rom[nb_option_roms] = strdup(buf);
9259 nb_option_roms++;
9260 netroms++;
9261 }
9262 }
eec85c2a 9263 }
28c5af54 9264 if (netroms == 0) {
eec85c2a
TS		 9265 fprintf(stderr, "No valid PXE rom found for network device\n");
9266 exit(1);
9267 }
eec85c2a
TS		 9268 }
9269#endif
9270
0824d6fc 9271 /* init the memory */
7fb4fdcf
AZ		 9272 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
9273
9274 if (machine->ram_require & RAMSIZE_FIXED) {
9275 if (ram_size > 0) {
9276 if (ram_size < phys_ram_size) {
cd940061
AJ		 9277 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
9278 machine->name, (unsigned long long) phys_ram_size);
7fb4fdcf
AZ		 9279 exit(-1);
9280 }
9281
9282 phys_ram_size = ram_size;
9283 } else
9284 ram_size = phys_ram_size;
9285 } else {
4fc5d071 9286 if (ram_size == 0)
7fb4fdcf
AZ		 9287 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9288
9289 phys_ram_size += ram_size;
9290 }
9ae02555 9291
d993e026 9292 phys_ram_base = qemu_vmalloc(phys_ram_size);
7f7f9873
FB		 9293 if (!phys_ram_base) {
9294 fprintf(stderr, "Could not allocate physical memory\n");
0824d6fc
FB		 9295 exit(1);
9296 }
9297
26a5f13b
FB		 9298 /* init the dynamic translator */
9299 cpu_exec_init_all(tb_size * 1024 * 1024);
9300
5905b2e5 9301 bdrv_init();
c4b1fcc0 9302
e4bcb14c 9303 /* we always create the cdrom drive, even if no disk is there */
c4b1fcc0 9304
e4bcb14c 9305 if (nb_drives_opt < MAX_DRIVES)
609497ab 9306 drive_add(NULL, CDROM_ALIAS);
c4b1fcc0 9307
9d413d1d 9308 /* we always create at least one floppy */
33e3963e 9309
e4bcb14c 9310 if (nb_drives_opt < MAX_DRIVES)
609497ab 9311 drive_add(NULL, FD_ALIAS, 0);
86f55663 9312
9d413d1d
AZ		 9313 /* we always create one sd slot, even if no card is in it */
9314
9315 if (nb_drives_opt < MAX_DRIVES)
609497ab 9316 drive_add(NULL, SD_ALIAS);
9d413d1d 9317
e4bcb14c
TS		 9318 /* open the virtual block devices */
9319
9320 for(i = 0; i < nb_drives_opt; i++)
609497ab 9321 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
e4bcb14c 9322 exit(1);
3e3d5815 9323
c88676f8
FB		 9324 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
9325 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8a7ddc38 9326
313aa567 9327 /* terminal init */
740733bb 9328 memset(&display_state, 0, sizeof(display_state));
a20dd508 9329 if (nographic) {
4d3b6f6e
AZ		 9330 if (curses) {
9331 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
9332 exit(1);
9333 }
2ff89790
TS		 9334 /* nearly nothing to do */
9335 dumb_display_init(ds);
73fc9742 9336 } else if (vnc_display != NULL) {
71cab5ca
TS		 9337 vnc_display_init(ds);
9338 if (vnc_display_open(ds, vnc_display) < 0)
9339 exit(1);
4d3b6f6e
AZ		 9340 } else
9341#if defined(CONFIG_CURSES)
9342 if (curses) {
9343 curses_display_init(ds, full_screen);
9344 } else
9345#endif
9346 {
5b0753e0 9347#if defined(CONFIG_SDL)
43523e93 9348 sdl_display_init(ds, full_screen, no_frame);
5b0753e0
FB		 9349#elif defined(CONFIG_COCOA)
9350 cocoa_display_init(ds, full_screen);
67276f53
PB		 9351#else
9352 dumb_display_init(ds);
313aa567
FB		 9353#endif
9354 }
0824d6fc 9355
5b08fc10
AL		 9356#ifndef _WIN32
9357 /* must be after terminal init, SDL library changes signal handlers */
9358 termsig_setup();
9359#endif
9360
20d8a3ed
TS		 9361 /* Maintain compatibility with multiple stdio monitors */
9362 if (!strcmp(monitor_device,"stdio")) {
9363 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
fd5f393a
PB		 9364 const char *devname = serial_devices[i];
9365 if (devname && !strcmp(devname,"mon:stdio")) {
9366 monitor_device = NULL;
20d8a3ed 9367 break;
fd5f393a
PB		 9368 } else if (devname && !strcmp(devname,"stdio")) {
9369 monitor_device = NULL;
9370 serial_devices[i] = "mon:stdio";
20d8a3ed
TS		 9371 break;
9372 }
9373 }
9374 }
fd5f393a 9375 if (monitor_device) {
20d8a3ed
TS		 9376 monitor_hd = qemu_chr_open(monitor_device);
9377 if (!monitor_hd) {
9378 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
9379 exit(1);
9380 }
9381 monitor_init(monitor_hd, !nographic);
82c643ff 9382 }
82c643ff 9383
8d11df9e 9384 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
c03b0f0f 9385 const char *devname = serial_devices[i];
fd5f393a 9386 if (devname && strcmp(devname, "none")) {
c03b0f0f 9387 serial_hds[i] = qemu_chr_open(devname);
8d11df9e 9388 if (!serial_hds[i]) {
5fafdf24 9389 fprintf(stderr, "qemu: could not open serial device '%s'\n",
c03b0f0f 9390 devname);
8d11df9e
FB		 9391 exit(1);
9392 }
af3a9031 9393 if (strstart(devname, "vc", 0))
7ba1260a 9394 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8d11df9e 9395 }
82c643ff 9396 }
82c643ff 9397
6508fe59 9398 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
c03b0f0f 9399 const char *devname = parallel_devices[i];
fd5f393a 9400 if (devname && strcmp(devname, "none")) {
c03b0f0f 9401 parallel_hds[i] = qemu_chr_open(devname);
6508fe59 9402 if (!parallel_hds[i]) {
5fafdf24 9403 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
c03b0f0f 9404 devname);
6508fe59
FB		 9405 exit(1);
9406 }
af3a9031 9407 if (strstart(devname, "vc", 0))
7ba1260a 9408 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6508fe59
FB		 9409 }
9410 }
9411
b881c2c6 9412 machine->init(ram_size, vga_ram_size, boot_devices, ds,
94fc95cd 9413 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
73332e5c 9414
0d92ed30
PB		 9415 /* init USB devices */
9416 if (usb_enabled) {
9417 for(i = 0; i < usb_devices_index; i++) {
9418 if (usb_device_add(usb_devices[i]) < 0) {
9419 fprintf(stderr, "Warning: could not add USB device %s\n",
9420 usb_devices[i]);
9421 }
9422 }
9423 }
9424
740733bb
TS		 9425 if (display_state.dpy_refresh) {
9426 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
9427 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
9428 }
7f7f9873 9429
67b915a5 9430#ifdef CONFIG_GDBSTUB
b4608c04 9431 if (use_gdbstub) {
c636bb66
FB		 9432 /* XXX: use standard host:port notation and modify options
9433 accordingly. */
cfc3475a
PB		 9434 if (gdbserver_start(gdbstub_port) < 0) {
9435 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
c636bb66 9436 gdbstub_port);
8a7ddc38 9437 exit(1);
8a7ddc38 9438 }
45669e00 9439 }
67b915a5 9440#endif
45669e00 9441
d63d307f 9442 if (loadvm)
faea38e7 9443 do_loadvm(loadvm);
d63d307f 9444
67b915a5 9445 {
5905b2e5 9446 /* XXX: simplify init */
83ab7950 9447 read_passwords();
3c07f8e8 9448 if (autostart) {
5905b2e5
FB		 9449 vm_start();
9450 }
0824d6fc 9451 }
ffd843bc 9452
71e3ceb8
TS		 9453 if (daemonize) {
9454 uint8_t status = 0;
9455 ssize_t len;
9456 int fd;
9457
9458 again1:
9459 len = write(fds[1], &status, 1);
9460 if (len == -1 && (errno == EINTR))
9461 goto again1;
9462
9463 if (len != 1)
9464 exit(1);
9465
bd54b863 9466 chdir("/");
aeb30be6 9467 TFR(fd = open("/dev/null", O_RDWR));
71e3ceb8
TS		 9468 if (fd == -1)
9469 exit(1);
9470
9471 dup2(fd, 0);
9472 dup2(fd, 1);
9473 dup2(fd, 2);
9474
9475 close(fd);
9476 }
9477
8a7ddc38 9478 main_loop();
40c3bac3 9479 quit_timers();
b46a8906 9480
7d294b61 9481#if !defined(_WIN32)
b46a8906
TS		 9482 /* close network clients */
9483 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9484 VLANClientState *vc;
9485
7d294b61 9486 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
b46a8906
TS		 9487 if (vc->fd_read == tap_receive) {
9488 char ifname[64];
9489 TAPState *s = vc->opaque;
9490
9491 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9492 s->down_script[0])
9493 launch_script(s->down_script, ifname, s->fd);
9494 }
8a16d273
TS		 9495#if defined(CONFIG_VDE)
9496 if (vc->fd_read == vde_from_qemu) {
9497 VDEState *s = vc->opaque;
9498 vde_close(s->vde);
9499 }
9500#endif
4fddf62a 9501 }
7d294b61
TS		 9502 }
9503#endif
0824d6fc
FB		 9504 return 0;
9505}
QEMU mirror