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