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