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