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