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