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