vl.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   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.
  23  */
  24 #include "vl.h"
  25
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <signal.h>
  29 #include <time.h>
  30 #include <errno.h>
  31 #include <sys/time.h>
  32
  33 #ifndef _WIN32
  34 #include <sys/times.h>
  35 #include <sys/wait.h>
  36 #include <termios.h>
  37 #include <sys/poll.h>
  38 #include <sys/mman.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42 #include <dirent.h>
  43 #include <netdb.h>
  44 #ifdef _BSD
  45 #include <sys/stat.h>
  46 #ifndef __APPLE__
  47 #include <libutil.h>
  48 #endif
  49 #else
  50 #ifndef __sun__
  51 #include <linux/if.h>
  52 #include <linux/if_tun.h>
  53 #include <pty.h>
  54 #include <malloc.h>
  55 #include <linux/rtc.h>
  56 #include <linux/ppdev.h>
  57 #endif
  58 #endif
  59 #endif
  60
  61 #if defined(CONFIG_SLIRP)
  62 #include "libslirp.h"
  63 #endif
  64
  65 #ifdef _WIN32
  66 #include <malloc.h>
  67 #include <sys/timeb.h>
  68 #include <windows.h>
  69 #define getopt_long_only getopt_long
  70 #define memalign(align, size) malloc(size)
  71 #endif
  72
  73 #include "qemu_socket.h"
  74
  75 #ifdef CONFIG_SDL
  76 #ifdef __APPLE__
  77 #include <SDL/SDL.h>
  78 #endif
  79 #endif /* CONFIG_SDL */
  80
  81 #ifdef CONFIG_COCOA
  82 #undef main
  83 #define main qemu_main
  84 #endif /* CONFIG_COCOA */
  85
  86 #include "disas.h"
  87
  88 #include "exec-all.h"
  89
  90 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
  91
  92 //#define DEBUG_UNUSED_IOPORT
  93 //#define DEBUG_IOPORT
  94
  95 #if !defined(CONFIG_SOFTMMU)
  96 #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
  97 #else
  98 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
  99 #endif
 100
 101 #ifdef TARGET_PPC
 102 #define DEFAULT_RAM_SIZE 144
 103 #else
 104 #define DEFAULT_RAM_SIZE 128
 105 #endif
 106 /* in ms */
 107 #define GUI_REFRESH_INTERVAL 30
 108
 109 /* Max number of USB devices that can be specified on the commandline.  */
 110 #define MAX_USB_CMDLINE 8
 111
 112 /* XXX: use a two level table to limit memory usage */
 113 #define MAX_IOPORTS 65536
 114
 115 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
 116 char phys_ram_file[1024];
 117 void *ioport_opaque[MAX_IOPORTS];
 118 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
 119 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
 120 BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];
 121 int vga_ram_size;
 122 int bios_size;
 123 static DisplayState display_state;
 124 int nographic;
 125 const char* keyboard_layout = NULL;
 126 int64_t ticks_per_sec;
 127 int boot_device = 'c';
 128 int ram_size;
 129 int pit_min_timer_count = 0;
 130 int nb_nics;
 131 NICInfo nd_table[MAX_NICS];
 132 QEMUTimer *gui_timer;
 133 int vm_running;
 134 int rtc_utc = 1;
 135 int cirrus_vga_enabled = 1;
 136 #ifdef TARGET_SPARC
 137 int graphic_width = 1024;
 138 int graphic_height = 768;
 139 #else
 140 int graphic_width = 800;
 141 int graphic_height = 600;
 142 #endif
 143 int graphic_depth = 15;
 144 int full_screen = 0;
 145 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
 146 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
 147 #ifdef TARGET_I386
 148 int win2k_install_hack = 0;
 149 #endif
 150 int usb_enabled = 0;
 151 static VLANState *first_vlan;
 152 int smp_cpus = 1;
 153 int vnc_display = -1;
 154 #if defined(TARGET_SPARC)
 155 #define MAX_CPUS 16
 156 #elif defined(TARGET_I386)
 157 #define MAX_CPUS 255
 158 #else
 159 #define MAX_CPUS 1
 160 #endif
 161 int acpi_enabled = 1;
 162 int fd_bootchk = 1;
 163
 164 /***********************************************************/
 165 /* x86 ISA bus support */
 166
 167 target_phys_addr_t isa_mem_base = 0;
 168 PicState2 *isa_pic;
 169
 170 uint32_t default_ioport_readb(void *opaque, uint32_t address)
 171 {
 172 #ifdef DEBUG_UNUSED_IOPORT
 173     fprintf(stderr, "inb: port=0x%04x\n", address);
 174 #endif
 175     return 0xff;
 176 }
 177
 178 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
 179 {
 180 #ifdef DEBUG_UNUSED_IOPORT
 181     fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
 182 #endif
 183 }
 184
 185 /* default is to make two byte accesses */
 186 uint32_t default_ioport_readw(void *opaque, uint32_t address)
 187 {
 188     uint32_t data;
 189     data = ioport_read_table[0][address](ioport_opaque[address], address);
 190     address = (address + 1) & (MAX_IOPORTS - 1);
 191     data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
 192     return data;
 193 }
 194
 195 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
 196 {
 197     ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
 198     address = (address + 1) & (MAX_IOPORTS - 1);
 199     ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
 200 }
 201
 202 uint32_t default_ioport_readl(void *opaque, uint32_t address)
 203 {
 204 #ifdef DEBUG_UNUSED_IOPORT
 205     fprintf(stderr, "inl: port=0x%04x\n", address);
 206 #endif
 207     return 0xffffffff;
 208 }
 209
 210 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
 211 {
 212 #ifdef DEBUG_UNUSED_IOPORT
 213     fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
 214 #endif
 215 }
 216
 217 void init_ioports(void)
 218 {
 219     int i;
 220
 221     for(i = 0; i < MAX_IOPORTS; i++) {
 222         ioport_read_table[0][i] = default_ioport_readb;
 223         ioport_write_table[0][i] = default_ioport_writeb;
 224         ioport_read_table[1][i] = default_ioport_readw;
 225         ioport_write_table[1][i] = default_ioport_writew;
 226         ioport_read_table[2][i] = default_ioport_readl;
 227         ioport_write_table[2][i] = default_ioport_writel;
 228     }
 229 }
 230
 231 /* size is the word size in byte */
 232 int register_ioport_read(int start, int length, int size,
 233                          IOPortReadFunc *func, void *opaque)
 234 {
 235     int i, bsize;
 236
 237     if (size == 1) {
 238         bsize = 0;
 239     } else if (size == 2) {
 240         bsize = 1;
 241     } else if (size == 4) {
 242         bsize = 2;
 243     } else {
 244         hw_error("register_ioport_read: invalid size");
 245         return -1;
 246     }
 247     for(i = start; i < start + length; i += size) {
 248         ioport_read_table[bsize][i] = func;
 249         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 250             hw_error("register_ioport_read: invalid opaque");
 251         ioport_opaque[i] = opaque;
 252     }
 253     return 0;
 254 }
 255
 256 /* size is the word size in byte */
 257 int register_ioport_write(int start, int length, int size,
 258                           IOPortWriteFunc *func, void *opaque)
 259 {
 260     int i, bsize;
 261
 262     if (size == 1) {
 263         bsize = 0;
 264     } else if (size == 2) {
 265         bsize = 1;
 266     } else if (size == 4) {
 267         bsize = 2;
 268     } else {
 269         hw_error("register_ioport_write: invalid size");
 270         return -1;
 271     }
 272     for(i = start; i < start + length; i += size) {
 273         ioport_write_table[bsize][i] = func;
 274         if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
 275             hw_error("register_ioport_read: invalid opaque");
 276         ioport_opaque[i] = opaque;
 277     }
 278     return 0;
 279 }
 280
 281 void isa_unassign_ioport(int start, int length)
 282 {
 283     int i;
 284
 285     for(i = start; i < start + length; i++) {
 286         ioport_read_table[0][i] = default_ioport_readb;
 287         ioport_read_table[1][i] = default_ioport_readw;
 288         ioport_read_table[2][i] = default_ioport_readl;
 289
 290         ioport_write_table[0][i] = default_ioport_writeb;
 291         ioport_write_table[1][i] = default_ioport_writew;
 292         ioport_write_table[2][i] = default_ioport_writel;
 293     }
 294 }
 295
 296 /***********************************************************/
 297
 298 void pstrcpy(char *buf, int buf_size, const char *str)
 299 {
 300     int c;
 301     char *q = buf;
 302
 303     if (buf_size <= 0)
 304         return;
 305
 306     for(;;) {
 307         c = *str++;
 308         if (c == 0 || q >= buf + buf_size - 1)
 309             break;
 310         *q++ = c;
 311     }
 312     *q = '\0';
 313 }
 314
 315 /* strcat and truncate. */
 316 char *pstrcat(char *buf, int buf_size, const char *s)
 317 {
 318     int len;
 319     len = strlen(buf);
 320     if (len < buf_size)
 321         pstrcpy(buf + len, buf_size - len, s);
 322     return buf;
 323 }
 324
 325 int strstart(const char *str, const char *val, const char **ptr)
 326 {
 327     const char *p, *q;
 328     p = str;
 329     q = val;
 330     while (*q != '\0') {
 331         if (*p != *q)
 332             return 0;
 333         p++;
 334         q++;
 335     }
 336     if (ptr)
 337         *ptr = p;
 338     return 1;
 339 }
 340
 341 void cpu_outb(CPUState *env, int addr, int val)
 342 {
 343 #ifdef DEBUG_IOPORT
 344     if (loglevel & CPU_LOG_IOPORT)
 345         fprintf(logfile, "outb: %04x %02x\n", addr, val);
 346 #endif
 347     ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
 348 #ifdef USE_KQEMU
 349     if (env)
 350         env->last_io_time = cpu_get_time_fast();
 351 #endif
 352 }
 353
 354 void cpu_outw(CPUState *env, int addr, int val)
 355 {
 356 #ifdef DEBUG_IOPORT
 357     if (loglevel & CPU_LOG_IOPORT)
 358         fprintf(logfile, "outw: %04x %04x\n", addr, val);
 359 #endif
 360     ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
 361 #ifdef USE_KQEMU
 362     if (env)
 363         env->last_io_time = cpu_get_time_fast();
 364 #endif
 365 }
 366
 367 void cpu_outl(CPUState *env, int addr, int val)
 368 {
 369 #ifdef DEBUG_IOPORT
 370     if (loglevel & CPU_LOG_IOPORT)
 371         fprintf(logfile, "outl: %04x %08x\n", addr, val);
 372 #endif
 373     ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
 374 #ifdef USE_KQEMU
 375     if (env)
 376         env->last_io_time = cpu_get_time_fast();
 377 #endif
 378 }
 379
 380 int cpu_inb(CPUState *env, int addr)
 381 {
 382     int val;
 383     val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
 384 #ifdef DEBUG_IOPORT
 385     if (loglevel & CPU_LOG_IOPORT)
 386         fprintf(logfile, "inb : %04x %02x\n", addr, val);
 387 #endif
 388 #ifdef USE_KQEMU
 389     if (env)
 390         env->last_io_time = cpu_get_time_fast();
 391 #endif
 392     return val;
 393 }
 394
 395 int cpu_inw(CPUState *env, int addr)
 396 {
 397     int val;
 398     val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
 399 #ifdef DEBUG_IOPORT
 400     if (loglevel & CPU_LOG_IOPORT)
 401         fprintf(logfile, "inw : %04x %04x\n", addr, val);
 402 #endif
 403 #ifdef USE_KQEMU
 404     if (env)
 405         env->last_io_time = cpu_get_time_fast();
 406 #endif
 407     return val;
 408 }
 409
 410 int cpu_inl(CPUState *env, int addr)
 411 {
 412     int val;
 413     val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
 414 #ifdef DEBUG_IOPORT
 415     if (loglevel & CPU_LOG_IOPORT)
 416         fprintf(logfile, "inl : %04x %08x\n", addr, val);
 417 #endif
 418 #ifdef USE_KQEMU
 419     if (env)
 420         env->last_io_time = cpu_get_time_fast();
 421 #endif
 422     return val;
 423 }
 424
 425 /***********************************************************/
 426 void hw_error(const char *fmt, ...)
 427 {
 428     va_list ap;
 429     CPUState *env;
 430
 431     va_start(ap, fmt);
 432     fprintf(stderr, "qemu: hardware error: ");
 433     vfprintf(stderr, fmt, ap);
 434     fprintf(stderr, "\n");
 435     for(env = first_cpu; env != NULL; env = env->next_cpu) {
 436         fprintf(stderr, "CPU #%d:\n", env->cpu_index);
 437 #ifdef TARGET_I386
 438         cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
 439 #else
 440         cpu_dump_state(env, stderr, fprintf, 0);
 441 #endif
 442     }
 443     va_end(ap);
 444     abort();
 445 }
 446
 447 /***********************************************************/
 448 /* keyboard/mouse */
 449
 450 static QEMUPutKBDEvent *qemu_put_kbd_event;
 451 static void *qemu_put_kbd_event_opaque;
 452 static QEMUPutMouseEvent *qemu_put_mouse_event;
 453 static void *qemu_put_mouse_event_opaque;
 454 static int qemu_put_mouse_event_absolute;
 455
 456 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
 457 {
 458     qemu_put_kbd_event_opaque = opaque;
 459     qemu_put_kbd_event = func;
 460 }
 461
 462 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque, int absolute)
 463 {
 464     qemu_put_mouse_event_opaque = opaque;
 465     qemu_put_mouse_event = func;
 466     qemu_put_mouse_event_absolute = absolute;
 467 }
 468
 469 void kbd_put_keycode(int keycode)
 470 {
 471     if (qemu_put_kbd_event) {
 472         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
 473     }
 474 }
 475
 476 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
 477 {
 478     if (qemu_put_mouse_event) {
 479         qemu_put_mouse_event(qemu_put_mouse_event_opaque,
 480                              dx, dy, dz, buttons_state);
 481     }
 482 }
 483
 484 int kbd_mouse_is_absolute(void)
 485 {
 486     return qemu_put_mouse_event_absolute;
 487 }
 488
 489 /***********************************************************/
 490 /* timers */
 491
 492 #if defined(__powerpc__)
 493
 494 static inline uint32_t get_tbl(void)
 495 {
 496     uint32_t tbl;
 497     asm volatile("mftb %0" : "=r" (tbl));
 498     return tbl;
 499 }
 500
 501 static inline uint32_t get_tbu(void)
 502 {
 503         uint32_t tbl;
 504         asm volatile("mftbu %0" : "=r" (tbl));
 505         return tbl;
 506 }
 507
 508 int64_t cpu_get_real_ticks(void)
 509 {
 510     uint32_t l, h, h1;
 511     /* NOTE: we test if wrapping has occurred */
 512     do {
 513         h = get_tbu();
 514         l = get_tbl();
 515         h1 = get_tbu();
 516     } while (h != h1);
 517     return ((int64_t)h << 32) | l;
 518 }
 519
 520 #elif defined(__i386__)
 521
 522 int64_t cpu_get_real_ticks(void)
 523 {
 524 #ifdef _WIN32
 525     LARGE_INTEGER ti;
 526     QueryPerformanceCounter(&ti);
 527     return ti.QuadPart;
 528 #else
 529     int64_t val;
 530     asm volatile ("rdtsc" : "=A" (val));
 531     return val;
 532 #endif
 533 }
 534
 535 #elif defined(__x86_64__)
 536
 537 int64_t cpu_get_real_ticks(void)
 538 {
 539     uint32_t low,high;
 540     int64_t val;
 541     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 542     val = high;
 543     val <<= 32;
 544     val |= low;
 545     return val;
 546 }
 547
 548 #elif defined(__ia64)
 549
 550 int64_t cpu_get_real_ticks(void)
 551 {
 552         int64_t val;
 553         asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 554         return val;
 555 }
 556
 557 #elif defined(__s390__)
 558
 559 int64_t cpu_get_real_ticks(void)
 560 {
 561     int64_t val;
 562     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 563     return val;
 564 }
 565
 566 #elif defined(__sparc__) && defined(HOST_SOLARIS)
 567
 568 uint64_t cpu_get_real_ticks (void)
 569 {
 570 #if     defined(_LP64)
 571         uint64_t        rval;
 572         asm volatile("rd %%tick,%0" : "=r"(rval));
 573         return rval;
 574 #else
 575         union {
 576                 uint64_t i64;
 577                 struct {
 578                         uint32_t high;
 579                         uint32_t low;
 580                 }       i32;
 581         } rval;
 582         asm volatile("rd %%tick,%1; srlx %1,32,%0"
 583                 : "=r"(rval.i32.high), "=r"(rval.i32.low));
 584         return rval.i64;
 585 #endif
 586 }
 587
 588 #else
 589 #error unsupported CPU
 590 #endif
 591
 592 static int64_t cpu_ticks_prev;
 593 static int64_t cpu_ticks_offset;
 594 static int cpu_ticks_enabled;
 595
 596 static inline int64_t cpu_get_ticks(void)
 597 {
 598     if (!cpu_ticks_enabled) {
 599         return cpu_ticks_offset;
 600     } else {
 601         int64_t ticks;
 602         ticks = cpu_get_real_ticks();
 603         if (cpu_ticks_prev > ticks) {
 604             /* Note: non increasing ticks may happen if the host uses
 605                software suspend */
 606             cpu_ticks_offset += cpu_ticks_prev - ticks;
 607         }
 608         cpu_ticks_prev = ticks;
 609         return ticks + cpu_ticks_offset;
 610     }
 611 }
 612
 613 /* enable cpu_get_ticks() */
 614 void cpu_enable_ticks(void)
 615 {
 616     if (!cpu_ticks_enabled) {
 617         cpu_ticks_offset -= cpu_get_real_ticks();
 618         cpu_ticks_enabled = 1;
 619     }
 620 }
 621
 622 /* disable cpu_get_ticks() : the clock is stopped. You must not call
 623    cpu_get_ticks() after that.  */
 624 void cpu_disable_ticks(void)
 625 {
 626     if (cpu_ticks_enabled) {
 627         cpu_ticks_offset = cpu_get_ticks();
 628         cpu_ticks_enabled = 0;
 629     }
 630 }
 631
 632 #ifdef _WIN32
 633 void cpu_calibrate_ticks(void)
 634 {
 635     LARGE_INTEGER freq;
 636     int ret;
 637
 638     ret = QueryPerformanceFrequency(&freq);
 639     if (ret == 0) {
 640         fprintf(stderr, "Could not calibrate ticks\n");
 641         exit(1);
 642     }
 643     ticks_per_sec = freq.QuadPart;
 644 }
 645
 646 #else
 647 static int64_t get_clock(void)
 648 {
 649     struct timeval tv;
 650     gettimeofday(&tv, NULL);
 651     return tv.tv_sec * 1000000LL + tv.tv_usec;
 652 }
 653
 654 void cpu_calibrate_ticks(void)
 655 {
 656     int64_t usec, ticks;
 657
 658     usec = get_clock();
 659     ticks = cpu_get_real_ticks();
 660     usleep(50 * 1000);
 661     usec = get_clock() - usec;
 662     ticks = cpu_get_real_ticks() - ticks;
 663     ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
 664 }
 665 #endif /* !_WIN32 */
 666
 667 /* compute with 96 bit intermediate result: (a*b)/c */
 668 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
 669 {
 670     union {
 671         uint64_t ll;
 672         struct {
 673 #ifdef WORDS_BIGENDIAN
 674             uint32_t high, low;
 675 #else
 676             uint32_t low, high;
 677 #endif
 678         } l;
 679     } u, res;
 680     uint64_t rl, rh;
 681
 682     u.ll = a;
 683     rl = (uint64_t)u.l.low * (uint64_t)b;
 684     rh = (uint64_t)u.l.high * (uint64_t)b;
 685     rh += (rl >> 32);
 686     res.l.high = rh / c;
 687     res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
 688     return res.ll;
 689 }
 690
 691 #define QEMU_TIMER_REALTIME 0
 692 #define QEMU_TIMER_VIRTUAL  1
 693
 694 struct QEMUClock {
 695     int type;
 696     /* XXX: add frequency */
 697 };
 698
 699 struct QEMUTimer {
 700     QEMUClock *clock;
 701     int64_t expire_time;
 702     QEMUTimerCB *cb;
 703     void *opaque;
 704     struct QEMUTimer *next;
 705 };
 706
 707 QEMUClock *rt_clock;
 708 QEMUClock *vm_clock;
 709
 710 static QEMUTimer *active_timers[2];
 711 #ifdef _WIN32
 712 static MMRESULT timerID;
 713 static HANDLE host_alarm = NULL;
 714 static unsigned int period = 1;
 715 #else
 716 /* frequency of the times() clock tick */
 717 static int timer_freq;
 718 #endif
 719
 720 QEMUClock *qemu_new_clock(int type)
 721 {
 722     QEMUClock *clock;
 723     clock = qemu_mallocz(sizeof(QEMUClock));
 724     if (!clock)
 725         return NULL;
 726     clock->type = type;
 727     return clock;
 728 }
 729
 730 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
 731 {
 732     QEMUTimer *ts;
 733
 734     ts = qemu_mallocz(sizeof(QEMUTimer));
 735     ts->clock = clock;
 736     ts->cb = cb;
 737     ts->opaque = opaque;
 738     return ts;
 739 }
 740
 741 void qemu_free_timer(QEMUTimer *ts)
 742 {
 743     qemu_free(ts);
 744 }
 745
 746 /* stop a timer, but do not dealloc it */
 747 void qemu_del_timer(QEMUTimer *ts)
 748 {
 749     QEMUTimer **pt, *t;
 750
 751     /* NOTE: this code must be signal safe because
 752        qemu_timer_expired() can be called from a signal. */
 753     pt = &active_timers[ts->clock->type];
 754     for(;;) {
 755         t = *pt;
 756         if (!t)
 757             break;
 758         if (t == ts) {
 759             *pt = t->next;
 760             break;
 761         }
 762         pt = &t->next;
 763     }
 764 }
 765
 766 /* modify the current timer so that it will be fired when current_time
 767    >= expire_time. The corresponding callback will be called. */
 768 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
 769 {
 770     QEMUTimer **pt, *t;
 771
 772     qemu_del_timer(ts);
 773
 774     /* add the timer in the sorted list */
 775     /* NOTE: this code must be signal safe because
 776        qemu_timer_expired() can be called from a signal. */
 777     pt = &active_timers[ts->clock->type];
 778     for(;;) {
 779         t = *pt;
 780         if (!t)
 781             break;
 782         if (t->expire_time > expire_time)
 783             break;
 784         pt = &t->next;
 785     }
 786     ts->expire_time = expire_time;
 787     ts->next = *pt;
 788     *pt = ts;
 789 }
 790
 791 int qemu_timer_pending(QEMUTimer *ts)
 792 {
 793     QEMUTimer *t;
 794     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
 795         if (t == ts)
 796             return 1;
 797     }
 798     return 0;
 799 }
 800
 801 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
 802 {
 803     if (!timer_head)
 804         return 0;
 805     return (timer_head->expire_time <= current_time);
 806 }
 807
 808 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
 809 {
 810     QEMUTimer *ts;
 811
 812     for(;;) {
 813         ts = *ptimer_head;
 814         if (!ts || ts->expire_time > current_time)
 815             break;
 816         /* remove timer from the list before calling the callback */
 817         *ptimer_head = ts->next;
 818         ts->next = NULL;
 819
 820         /* run the callback (the timer list can be modified) */
 821         ts->cb(ts->opaque);
 822     }
 823 }
 824
 825 int64_t qemu_get_clock(QEMUClock *clock)
 826 {
 827     switch(clock->type) {
 828     case QEMU_TIMER_REALTIME:
 829 #ifdef _WIN32
 830         return GetTickCount();
 831 #else
 832         {
 833             struct tms tp;
 834
 835             /* Note that using gettimeofday() is not a good solution
 836                for timers because its value change when the date is
 837                modified. */
 838             if (timer_freq == 100) {
 839                 return times(&tp) * 10;
 840             } else {
 841                 return ((int64_t)times(&tp) * 1000) / timer_freq;
 842             }
 843         }
 844 #endif
 845     default:
 846     case QEMU_TIMER_VIRTUAL:
 847         return cpu_get_ticks();
 848     }
 849 }
 850
 851 /* save a timer */
 852 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
 853 {
 854     uint64_t expire_time;
 855
 856     if (qemu_timer_pending(ts)) {
 857         expire_time = ts->expire_time;
 858     } else {
 859         expire_time = -1;
 860     }
 861     qemu_put_be64(f, expire_time);
 862 }
 863
 864 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
 865 {
 866     uint64_t expire_time;
 867
 868     expire_time = qemu_get_be64(f);
 869     if (expire_time != -1) {
 870         qemu_mod_timer(ts, expire_time);
 871     } else {
 872         qemu_del_timer(ts);
 873     }
 874 }
 875
 876 static void timer_save(QEMUFile *f, void *opaque)
 877 {
 878     if (cpu_ticks_enabled) {
 879         hw_error("cannot save state if virtual timers are running");
 880     }
 881     qemu_put_be64s(f, &cpu_ticks_offset);
 882     qemu_put_be64s(f, &ticks_per_sec);
 883 }
 884
 885 static int timer_load(QEMUFile *f, void *opaque, int version_id)
 886 {
 887     if (version_id != 1)
 888         return -EINVAL;
 889     if (cpu_ticks_enabled) {
 890         return -EINVAL;
 891     }
 892     qemu_get_be64s(f, &cpu_ticks_offset);
 893     qemu_get_be64s(f, &ticks_per_sec);
 894     return 0;
 895 }
 896
 897 #ifdef _WIN32
 898 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
 899                                  DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
 900 #else
 901 static void host_alarm_handler(int host_signum)
 902 #endif
 903 {
 904 #if 0
 905 #define DISP_FREQ 1000
 906     {
 907         static int64_t delta_min = INT64_MAX;
 908         static int64_t delta_max, delta_cum, last_clock, delta, ti;
 909         static int count;
 910         ti = qemu_get_clock(vm_clock);
 911         if (last_clock != 0) {
 912             delta = ti - last_clock;
 913             if (delta < delta_min)
 914                 delta_min = delta;
 915             if (delta > delta_max)
 916                 delta_max = delta;
 917             delta_cum += delta;
 918             if (++count == DISP_FREQ) {
 919                 printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",
 920                        muldiv64(delta_min, 1000000, ticks_per_sec),
 921                        muldiv64(delta_max, 1000000, ticks_per_sec),
 922                        muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
 923                        (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
 924                 count = 0;
 925                 delta_min = INT64_MAX;
 926                 delta_max = 0;
 927                 delta_cum = 0;
 928             }
 929         }
 930         last_clock = ti;
 931     }
 932 #endif
 933     if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
 934                            qemu_get_clock(vm_clock)) ||
 935         qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
 936                            qemu_get_clock(rt_clock))) {
 937 #ifdef _WIN32
 938         SetEvent(host_alarm);
 939 #endif
 940         CPUState *env = cpu_single_env;
 941         if (env) {
 942             /* stop the currently executing cpu because a timer occured */
 943             cpu_interrupt(env, CPU_INTERRUPT_EXIT);
 944 #ifdef USE_KQEMU
 945             if (env->kqemu_enabled) {
 946                 kqemu_cpu_interrupt(env);
 947             }
 948 #endif
 949         }
 950     }
 951 }
 952
 953 #ifndef _WIN32
 954
 955 #if defined(__linux__)
 956
 957 #define RTC_FREQ 1024
 958
 959 static int rtc_fd;
 960
 961 static int start_rtc_timer(void)
 962 {
 963     rtc_fd = open("/dev/rtc", O_RDONLY);
 964     if (rtc_fd < 0)
 965         return -1;
 966     if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
 967         fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
 968                 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
 969                 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
 970         goto fail;
 971     }
 972     if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
 973     fail:
 974         close(rtc_fd);
 975         return -1;
 976     }
 977     pit_min_timer_count = PIT_FREQ / RTC_FREQ;
 978     return 0;
 979 }
 980
 981 #else
 982
 983 static int start_rtc_timer(void)
 984 {
 985     return -1;
 986 }
 987
 988 #endif /* !defined(__linux__) */
 989
 990 #endif /* !defined(_WIN32) */
 991
 992 static void init_timers(void)
 993 {
 994     rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
 995     vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
 996
 997 #ifdef _WIN32
 998     {
 999         int count=0;
1000         TIMECAPS tc;
1001
1002         ZeroMemory(&tc, sizeof(TIMECAPS));
1003         timeGetDevCaps(&tc, sizeof(TIMECAPS));
1004         if (period < tc.wPeriodMin)
1005             period = tc.wPeriodMin;
1006         timeBeginPeriod(period);
1007         timerID = timeSetEvent(1,     // interval (ms)
1008                                period,     // resolution
1009                                host_alarm_handler, // function
1010                                (DWORD)&count,  // user parameter
1011                                TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
1012         if( !timerID ) {
1013             perror("failed timer alarm");
1014             exit(1);
1015         }
1016         host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1017         if (!host_alarm) {
1018             perror("failed CreateEvent");
1019             exit(1);
1020         }
1021         ResetEvent(host_alarm);
1022     }
1023     pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
1024 #else
1025     {
1026         struct sigaction act;
1027         struct itimerval itv;
1028
1029         /* get times() syscall frequency */
1030         timer_freq = sysconf(_SC_CLK_TCK);
1031
1032         /* timer signal */
1033         sigfillset(&act.sa_mask);
1034        act.sa_flags = 0;
1035 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
1036         act.sa_flags |= SA_ONSTACK;
1037 #endif
1038         act.sa_handler = host_alarm_handler;
1039         sigaction(SIGALRM, &act, NULL);
1040
1041         itv.it_interval.tv_sec = 0;
1042         itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
1043         itv.it_value.tv_sec = 0;
1044         itv.it_value.tv_usec = 10 * 1000;
1045         setitimer(ITIMER_REAL, &itv, NULL);
1046         /* we probe the tick duration of the kernel to inform the user if
1047            the emulated kernel requested a too high timer frequency */
1048         getitimer(ITIMER_REAL, &itv);
1049
1050 #if defined(__linux__)
1051         /* XXX: force /dev/rtc usage because even 2.6 kernels may not
1052            have timers with 1 ms resolution. The correct solution will
1053            be to use the POSIX real time timers available in recent
1054            2.6 kernels */
1055         if (itv.it_interval.tv_usec > 1000 || 1) {
1056             /* try to use /dev/rtc to have a faster timer */
1057             if (start_rtc_timer() < 0)
1058                 goto use_itimer;
1059             /* disable itimer */
1060             itv.it_interval.tv_sec = 0;
1061             itv.it_interval.tv_usec = 0;
1062             itv.it_value.tv_sec = 0;
1063             itv.it_value.tv_usec = 0;
1064             setitimer(ITIMER_REAL, &itv, NULL);
1065
1066             /* use the RTC */
1067             sigaction(SIGIO, &act, NULL);
1068             fcntl(rtc_fd, F_SETFL, O_ASYNC);
1069             fcntl(rtc_fd, F_SETOWN, getpid());
1070         } else
1071 #endif /* defined(__linux__) */
1072         {
1073         use_itimer:
1074             pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
1075                                    PIT_FREQ) / 1000000;
1076         }
1077     }
1078 #endif
1079 }
1080
1081 void quit_timers(void)
1082 {
1083 #ifdef _WIN32
1084     timeKillEvent(timerID);
1085     timeEndPeriod(period);
1086     if (host_alarm) {
1087         CloseHandle(host_alarm);
1088         host_alarm = NULL;
1089     }
1090 #endif
1091 }
1092
1093 /***********************************************************/
1094 /* character device */
1095
1096 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1097 {
1098     return s->chr_write(s, buf, len);
1099 }
1100
1101 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1102 {
1103     if (!s->chr_ioctl)
1104         return -ENOTSUP;
1105     return s->chr_ioctl(s, cmd, arg);
1106 }
1107
1108 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1109 {
1110     char buf[4096];
1111     va_list ap;
1112     va_start(ap, fmt);
1113     vsnprintf(buf, sizeof(buf), fmt, ap);
1114     qemu_chr_write(s, buf, strlen(buf));
1115     va_end(ap);
1116 }
1117
1118 void qemu_chr_send_event(CharDriverState *s, int event)
1119 {
1120     if (s->chr_send_event)
1121         s->chr_send_event(s, event);
1122 }
1123
1124 void qemu_chr_add_read_handler(CharDriverState *s,
1125                                IOCanRWHandler *fd_can_read,
1126                                IOReadHandler *fd_read, void *opaque)
1127 {
1128     s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1129 }
1130
1131 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1132 {
1133     s->chr_event = chr_event;
1134 }
1135
1136 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1137 {
1138     return len;
1139 }
1140
1141 static void null_chr_add_read_handler(CharDriverState *chr,
1142                                     IOCanRWHandler *fd_can_read,
1143                                     IOReadHandler *fd_read, void *opaque)
1144 {
1145 }
1146
1147 CharDriverState *qemu_chr_open_null(void)
1148 {
1149     CharDriverState *chr;
1150
1151     chr = qemu_mallocz(sizeof(CharDriverState));
1152     if (!chr)
1153         return NULL;
1154     chr->chr_write = null_chr_write;
1155     chr->chr_add_read_handler = null_chr_add_read_handler;
1156     return chr;
1157 }
1158
1159 #ifdef _WIN32
1160
1161 static void socket_cleanup(void)
1162 {
1163     WSACleanup();
1164 }
1165
1166 static int socket_init(void)
1167 {
1168     WSADATA Data;
1169     int ret, err;
1170
1171     ret = WSAStartup(MAKEWORD(2,2), &Data);
1172     if (ret != 0) {
1173         err = WSAGetLastError();
1174         fprintf(stderr, "WSAStartup: %d\n", err);
1175         return -1;
1176     }
1177     atexit(socket_cleanup);
1178     return 0;
1179 }
1180
1181 static int send_all(int fd, const uint8_t *buf, int len1)
1182 {
1183     int ret, len;
1184
1185     len = len1;
1186     while (len > 0) {
1187         ret = send(fd, buf, len, 0);
1188         if (ret < 0) {
1189             int errno;
1190             errno = WSAGetLastError();
1191             if (errno != WSAEWOULDBLOCK) {
1192                 return -1;
1193             }
1194         } else if (ret == 0) {
1195             break;
1196         } else {
1197             buf += ret;
1198             len -= ret;
1199         }
1200     }
1201     return len1 - len;
1202 }
1203
1204 void socket_set_nonblock(int fd)
1205 {
1206     unsigned long opt = 1;
1207     ioctlsocket(fd, FIONBIO, &opt);
1208 }
1209
1210 #else
1211
1212 static int unix_write(int fd, const uint8_t *buf, int len1)
1213 {
1214     int ret, len;
1215
1216     len = len1;
1217     while (len > 0) {
1218         ret = write(fd, buf, len);
1219         if (ret < 0) {
1220             if (errno != EINTR && errno != EAGAIN)
1221                 return -1;
1222         } else if (ret == 0) {
1223             break;
1224         } else {
1225             buf += ret;
1226             len -= ret;
1227         }
1228     }
1229     return len1 - len;
1230 }
1231
1232 static inline int send_all(int fd, const uint8_t *buf, int len1)
1233 {
1234     return unix_write(fd, buf, len1);
1235 }
1236
1237 void socket_set_nonblock(int fd)
1238 {
1239     fcntl(fd, F_SETFL, O_NONBLOCK);
1240 }
1241 #endif /* !_WIN32 */
1242
1243 #ifndef _WIN32
1244
1245 typedef struct {
1246     int fd_in, fd_out;
1247     IOCanRWHandler *fd_can_read;
1248     IOReadHandler *fd_read;
1249     void *fd_opaque;
1250     int max_size;
1251 } FDCharDriver;
1252
1253 #define STDIO_MAX_CLIENTS 2
1254
1255 static int stdio_nb_clients;
1256 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1257
1258 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1259 {
1260     FDCharDriver *s = chr->opaque;
1261     return unix_write(s->fd_out, buf, len);
1262 }
1263
1264 static int fd_chr_read_poll(void *opaque)
1265 {
1266     CharDriverState *chr = opaque;
1267     FDCharDriver *s = chr->opaque;
1268
1269     s->max_size = s->fd_can_read(s->fd_opaque);
1270     return s->max_size;
1271 }
1272
1273 static void fd_chr_read(void *opaque)
1274 {
1275     CharDriverState *chr = opaque;
1276     FDCharDriver *s = chr->opaque;
1277     int size, len;
1278     uint8_t buf[1024];
1279
1280     len = sizeof(buf);
1281     if (len > s->max_size)
1282         len = s->max_size;
1283     if (len == 0)
1284         return;
1285     size = read(s->fd_in, buf, len);
1286     if (size > 0) {
1287         s->fd_read(s->fd_opaque, buf, size);
1288     }
1289 }
1290
1291 static void fd_chr_add_read_handler(CharDriverState *chr,
1292                                     IOCanRWHandler *fd_can_read,
1293                                     IOReadHandler *fd_read, void *opaque)
1294 {
1295     FDCharDriver *s = chr->opaque;
1296
1297     if (s->fd_in >= 0) {
1298         s->fd_can_read = fd_can_read;
1299         s->fd_read = fd_read;
1300         s->fd_opaque = opaque;
1301         if (nographic && s->fd_in == 0) {
1302         } else {
1303             qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1304                                  fd_chr_read, NULL, chr);
1305         }
1306     }
1307 }
1308
1309 /* open a character device to a unix fd */
1310 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1311 {
1312     CharDriverState *chr;
1313     FDCharDriver *s;
1314
1315     chr = qemu_mallocz(sizeof(CharDriverState));
1316     if (!chr)
1317         return NULL;
1318     s = qemu_mallocz(sizeof(FDCharDriver));
1319     if (!s) {
1320         free(chr);
1321         return NULL;
1322     }
1323     s->fd_in = fd_in;
1324     s->fd_out = fd_out;
1325     chr->opaque = s;
1326     chr->chr_write = fd_chr_write;
1327     chr->chr_add_read_handler = fd_chr_add_read_handler;
1328     return chr;
1329 }
1330
1331 CharDriverState *qemu_chr_open_file_out(const char *file_out)
1332 {
1333     int fd_out;
1334
1335     fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666);
1336     if (fd_out < 0)
1337         return NULL;
1338     return qemu_chr_open_fd(-1, fd_out);
1339 }
1340
1341 CharDriverState *qemu_chr_open_pipe(const char *filename)
1342 {
1343     int fd;
1344
1345     fd = open(filename, O_RDWR | O_BINARY);
1346     if (fd < 0)
1347         return NULL;
1348     return qemu_chr_open_fd(fd, fd);
1349 }
1350
1351
1352 /* for STDIO, we handle the case where several clients use it
1353    (nographic mode) */
1354
1355 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1356
1357 #define TERM_FIFO_MAX_SIZE 1
1358
1359 static int term_got_escape, client_index;
1360 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1361 int term_fifo_size;
1362
1363 void term_print_help(void)
1364 {
1365     printf("\n"
1366            "C-a h    print this help\n"
1367            "C-a x    exit emulator\n"
1368            "C-a s    save disk data back to file (if -snapshot)\n"
1369            "C-a b    send break (magic sysrq)\n"
1370            "C-a c    switch between console and monitor\n"
1371            "C-a C-a  send C-a\n"
1372            );
1373 }
1374
1375 /* called when a char is received */
1376 static void stdio_received_byte(int ch)
1377 {
1378     if (term_got_escape) {
1379         term_got_escape = 0;
1380         switch(ch) {
1381         case 'h':
1382             term_print_help();
1383             break;
1384         case 'x':
1385             exit(0);
1386             break;
1387         case 's':
1388             {
1389                 int i;
1390                 for (i = 0; i < MAX_DISKS; i++) {
1391                     if (bs_table[i])
1392                         bdrv_commit(bs_table[i]);
1393                 }
1394             }
1395             break;
1396         case 'b':
1397             if (client_index < stdio_nb_clients) {
1398                 CharDriverState *chr;
1399                 FDCharDriver *s;
1400
1401                 chr = stdio_clients[client_index];
1402                 s = chr->opaque;
1403                 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1404             }
1405             break;
1406         case 'c':
1407             client_index++;
1408             if (client_index >= stdio_nb_clients)
1409                 client_index = 0;
1410             if (client_index == 0) {
1411                 /* send a new line in the monitor to get the prompt */
1412                 ch = '\r';
1413                 goto send_char;
1414             }
1415             break;
1416         case TERM_ESCAPE:
1417             goto send_char;
1418         }
1419     } else if (ch == TERM_ESCAPE) {
1420         term_got_escape = 1;
1421     } else {
1422     send_char:
1423         if (client_index < stdio_nb_clients) {
1424             uint8_t buf[1];
1425             CharDriverState *chr;
1426             FDCharDriver *s;
1427
1428             chr = stdio_clients[client_index];
1429             s = chr->opaque;
1430             if (s->fd_can_read(s->fd_opaque) > 0) {
1431                 buf[0] = ch;
1432                 s->fd_read(s->fd_opaque, buf, 1);
1433             } else if (term_fifo_size == 0) {
1434                 term_fifo[term_fifo_size++] = ch;
1435             }
1436         }
1437     }
1438 }
1439
1440 static int stdio_read_poll(void *opaque)
1441 {
1442     CharDriverState *chr;
1443     FDCharDriver *s;
1444
1445     if (client_index < stdio_nb_clients) {
1446         chr = stdio_clients[client_index];
1447         s = chr->opaque;
1448         /* try to flush the queue if needed */
1449         if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1450             s->fd_read(s->fd_opaque, term_fifo, 1);
1451             term_fifo_size = 0;
1452         }
1453         /* see if we can absorb more chars */
1454         if (term_fifo_size == 0)
1455             return 1;
1456         else
1457             return 0;
1458     } else {
1459         return 1;
1460     }
1461 }
1462
1463 static void stdio_read(void *opaque)
1464 {
1465     int size;
1466     uint8_t buf[1];
1467
1468     size = read(0, buf, 1);
1469     if (size > 0)
1470         stdio_received_byte(buf[0]);
1471 }
1472
1473 /* init terminal so that we can grab keys */
1474 static struct termios oldtty;
1475 static int old_fd0_flags;
1476
1477 static void term_exit(void)
1478 {
1479     tcsetattr (0, TCSANOW, &oldtty);
1480     fcntl(0, F_SETFL, old_fd0_flags);
1481 }
1482
1483 static void term_init(void)
1484 {
1485     struct termios tty;
1486
1487     tcgetattr (0, &tty);
1488     oldtty = tty;
1489     old_fd0_flags = fcntl(0, F_GETFL);
1490
1491     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1492                           |INLCR|IGNCR|ICRNL|IXON);
1493     tty.c_oflag |= OPOST;
1494     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1495     /* if graphical mode, we allow Ctrl-C handling */
1496     if (nographic)
1497         tty.c_lflag &= ~ISIG;
1498     tty.c_cflag &= ~(CSIZE|PARENB);
1499     tty.c_cflag |= CS8;
1500     tty.c_cc[VMIN] = 1;
1501     tty.c_cc[VTIME] = 0;
1502
1503     tcsetattr (0, TCSANOW, &tty);
1504
1505     atexit(term_exit);
1506
1507     fcntl(0, F_SETFL, O_NONBLOCK);
1508 }
1509
1510 CharDriverState *qemu_chr_open_stdio(void)
1511 {
1512     CharDriverState *chr;
1513
1514     if (nographic) {
1515         if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1516             return NULL;
1517         chr = qemu_chr_open_fd(0, 1);
1518         if (stdio_nb_clients == 0)
1519             qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);
1520         client_index = stdio_nb_clients;
1521     } else {
1522         if (stdio_nb_clients != 0)
1523             return NULL;
1524         chr = qemu_chr_open_fd(0, 1);
1525     }
1526     stdio_clients[stdio_nb_clients++] = chr;
1527     if (stdio_nb_clients == 1) {
1528         /* set the terminal in raw mode */
1529         term_init();
1530     }
1531     return chr;
1532 }
1533
1534 #if defined(__linux__)
1535 CharDriverState *qemu_chr_open_pty(void)
1536 {
1537     struct termios tty;
1538     char slave_name[1024];
1539     int master_fd, slave_fd;
1540
1541     /* Not satisfying */
1542     if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1543         return NULL;
1544     }
1545
1546     /* Disabling local echo and line-buffered output */
1547     tcgetattr (master_fd, &tty);
1548     tty.c_lflag &= ~(ECHO|ICANON|ISIG);
1549     tty.c_cc[VMIN] = 1;
1550     tty.c_cc[VTIME] = 0;
1551     tcsetattr (master_fd, TCSAFLUSH, &tty);
1552
1553     fprintf(stderr, "char device redirected to %s\n", slave_name);
1554     return qemu_chr_open_fd(master_fd, master_fd);
1555 }
1556
1557 static void tty_serial_init(int fd, int speed,
1558                             int parity, int data_bits, int stop_bits)
1559 {
1560     struct termios tty;
1561     speed_t spd;
1562
1563 #if 0
1564     printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1565            speed, parity, data_bits, stop_bits);
1566 #endif
1567     tcgetattr (fd, &tty);
1568
1569     switch(speed) {
1570     case 50:
1571         spd = B50;
1572         break;
1573     case 75:
1574         spd = B75;
1575         break;
1576     case 300:
1577         spd = B300;
1578         break;
1579     case 600:
1580         spd = B600;
1581         break;
1582     case 1200:
1583         spd = B1200;
1584         break;
1585     case 2400:
1586         spd = B2400;
1587         break;
1588     case 4800:
1589         spd = B4800;
1590         break;
1591     case 9600:
1592         spd = B9600;
1593         break;
1594     case 19200:
1595         spd = B19200;
1596         break;
1597     case 38400:
1598         spd = B38400;
1599         break;
1600     case 57600:
1601         spd = B57600;
1602         break;
1603     default:
1604     case 115200:
1605         spd = B115200;
1606         break;
1607     }
1608
1609     cfsetispeed(&tty, spd);
1610     cfsetospeed(&tty, spd);
1611
1612     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1613                           |INLCR|IGNCR|ICRNL|IXON);
1614     tty.c_oflag |= OPOST;
1615     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1616     tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS);
1617     switch(data_bits) {
1618     default:
1619     case 8:
1620         tty.c_cflag |= CS8;
1621         break;
1622     case 7:
1623         tty.c_cflag |= CS7;
1624         break;
1625     case 6:
1626         tty.c_cflag |= CS6;
1627         break;
1628     case 5:
1629         tty.c_cflag |= CS5;
1630         break;
1631     }
1632     switch(parity) {
1633     default:
1634     case 'N':
1635         break;
1636     case 'E':
1637         tty.c_cflag |= PARENB;
1638         break;
1639     case 'O':
1640         tty.c_cflag |= PARENB | PARODD;
1641         break;
1642     }
1643
1644     tcsetattr (fd, TCSANOW, &tty);
1645 }
1646
1647 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1648 {
1649     FDCharDriver *s = chr->opaque;
1650
1651     switch(cmd) {
1652     case CHR_IOCTL_SERIAL_SET_PARAMS:
1653         {
1654             QEMUSerialSetParams *ssp = arg;
1655             tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1656                             ssp->data_bits, ssp->stop_bits);
1657         }
1658         break;
1659     case CHR_IOCTL_SERIAL_SET_BREAK:
1660         {
1661             int enable = *(int *)arg;
1662             if (enable)
1663                 tcsendbreak(s->fd_in, 1);
1664         }
1665         break;
1666     default:
1667         return -ENOTSUP;
1668     }
1669     return 0;
1670 }
1671
1672 CharDriverState *qemu_chr_open_tty(const char *filename)
1673 {
1674     CharDriverState *chr;
1675     int fd;
1676
1677     fd = open(filename, O_RDWR | O_NONBLOCK);
1678     if (fd < 0)
1679         return NULL;
1680     fcntl(fd, F_SETFL, O_NONBLOCK);
1681     tty_serial_init(fd, 115200, 'N', 8, 1);
1682     chr = qemu_chr_open_fd(fd, fd);
1683     if (!chr)
1684         return NULL;
1685     chr->chr_ioctl = tty_serial_ioctl;
1686     return chr;
1687 }
1688
1689 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1690 {
1691     int fd = (int)chr->opaque;
1692     uint8_t b;
1693
1694     switch(cmd) {
1695     case CHR_IOCTL_PP_READ_DATA:
1696         if (ioctl(fd, PPRDATA, &b) < 0)
1697             return -ENOTSUP;
1698         *(uint8_t *)arg = b;
1699         break;
1700     case CHR_IOCTL_PP_WRITE_DATA:
1701         b = *(uint8_t *)arg;
1702         if (ioctl(fd, PPWDATA, &b) < 0)
1703             return -ENOTSUP;
1704         break;
1705     case CHR_IOCTL_PP_READ_CONTROL:
1706         if (ioctl(fd, PPRCONTROL, &b) < 0)
1707             return -ENOTSUP;
1708         *(uint8_t *)arg = b;
1709         break;
1710     case CHR_IOCTL_PP_WRITE_CONTROL:
1711         b = *(uint8_t *)arg;
1712         if (ioctl(fd, PPWCONTROL, &b) < 0)
1713             return -ENOTSUP;
1714         break;
1715     case CHR_IOCTL_PP_READ_STATUS:
1716         if (ioctl(fd, PPRSTATUS, &b) < 0)
1717             return -ENOTSUP;
1718         *(uint8_t *)arg = b;
1719         break;
1720     default:
1721         return -ENOTSUP;
1722     }
1723     return 0;
1724 }
1725
1726 CharDriverState *qemu_chr_open_pp(const char *filename)
1727 {
1728     CharDriverState *chr;
1729     int fd;
1730
1731     fd = open(filename, O_RDWR);
1732     if (fd < 0)
1733         return NULL;
1734
1735     if (ioctl(fd, PPCLAIM) < 0) {
1736         close(fd);
1737         return NULL;
1738     }
1739
1740     chr = qemu_mallocz(sizeof(CharDriverState));
1741     if (!chr) {
1742         close(fd);
1743         return NULL;
1744     }
1745     chr->opaque = (void *)fd;
1746     chr->chr_write = null_chr_write;
1747     chr->chr_add_read_handler = null_chr_add_read_handler;
1748     chr->chr_ioctl = pp_ioctl;
1749     return chr;
1750 }
1751
1752 #else
1753 CharDriverState *qemu_chr_open_pty(void)
1754 {
1755     return NULL;
1756 }
1757 #endif
1758
1759 #endif /* !defined(_WIN32) */
1760
1761 #ifdef _WIN32
1762 typedef struct {
1763     IOCanRWHandler *fd_can_read;
1764     IOReadHandler *fd_read;
1765     void *win_opaque;
1766     int max_size;
1767     HANDLE hcom, hrecv, hsend;
1768     OVERLAPPED orecv, osend;
1769     BOOL fpipe;
1770     DWORD len;
1771 } WinCharState;
1772
1773 #define NSENDBUF 2048
1774 #define NRECVBUF 2048
1775 #define MAXCONNECT 1
1776 #define NTIMEOUT 5000
1777
1778 static int win_chr_poll(void *opaque);
1779 static int win_chr_pipe_poll(void *opaque);
1780
1781 static void win_chr_close2(WinCharState *s)
1782 {
1783     if (s->hsend) {
1784         CloseHandle(s->hsend);
1785         s->hsend = NULL;
1786     }
1787     if (s->hrecv) {
1788         CloseHandle(s->hrecv);
1789         s->hrecv = NULL;
1790     }
1791     if (s->hcom) {
1792         CloseHandle(s->hcom);
1793         s->hcom = NULL;
1794     }
1795     if (s->fpipe)
1796         qemu_del_polling_cb(win_chr_pipe_poll, s);
1797     else
1798         qemu_del_polling_cb(win_chr_poll, s);
1799 }
1800
1801 static void win_chr_close(CharDriverState *chr)
1802 {
1803     WinCharState *s = chr->opaque;
1804     win_chr_close2(s);
1805 }
1806
1807 static int win_chr_init(WinCharState *s, const char *filename)
1808 {
1809     COMMCONFIG comcfg;
1810     COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1811     COMSTAT comstat;
1812     DWORD size;
1813     DWORD err;
1814
1815     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1816     if (!s->hsend) {
1817         fprintf(stderr, "Failed CreateEvent\n");
1818         goto fail;
1819     }
1820     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1821     if (!s->hrecv) {
1822         fprintf(stderr, "Failed CreateEvent\n");
1823         goto fail;
1824     }
1825
1826     s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1827                       OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1828     if (s->hcom == INVALID_HANDLE_VALUE) {
1829         fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1830         s->hcom = NULL;
1831         goto fail;
1832     }
1833
1834     if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1835         fprintf(stderr, "Failed SetupComm\n");
1836         goto fail;
1837     }
1838
1839     ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1840     size = sizeof(COMMCONFIG);
1841     GetDefaultCommConfig(filename, &comcfg, &size);
1842     comcfg.dcb.DCBlength = sizeof(DCB);
1843     CommConfigDialog(filename, NULL, &comcfg);
1844
1845     if (!SetCommState(s->hcom, &comcfg.dcb)) {
1846         fprintf(stderr, "Failed SetCommState\n");
1847         goto fail;
1848     }
1849
1850     if (!SetCommMask(s->hcom, EV_ERR)) {
1851         fprintf(stderr, "Failed SetCommMask\n");
1852         goto fail;
1853     }
1854
1855     cto.ReadIntervalTimeout = MAXDWORD;
1856     if (!SetCommTimeouts(s->hcom, &cto)) {
1857         fprintf(stderr, "Failed SetCommTimeouts\n");
1858         goto fail;
1859     }
1860
1861     if (!ClearCommError(s->hcom, &err, &comstat)) {
1862         fprintf(stderr, "Failed ClearCommError\n");
1863         goto fail;
1864     }
1865     qemu_add_polling_cb(win_chr_poll, s);
1866     return 0;
1867
1868  fail:
1869     win_chr_close2(s);
1870     return -1;
1871 }
1872
1873 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1874 {
1875     WinCharState *s = chr->opaque;
1876     DWORD len, ret, size, err;
1877
1878     len = len1;
1879     ZeroMemory(&s->osend, sizeof(s->osend));
1880     s->osend.hEvent = s->hsend;
1881     while (len > 0) {
1882         if (s->hsend)
1883             ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1884         else
1885             ret = WriteFile(s->hcom, buf, len, &size, NULL);
1886         if (!ret) {
1887             err = GetLastError();
1888             if (err == ERROR_IO_PENDING) {
1889                 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
1890                 if (ret) {
1891                     buf += size;
1892                     len -= size;
1893                 } else {
1894                     break;
1895                 }
1896             } else {
1897                 break;
1898             }
1899         } else {
1900             buf += size;
1901             len -= size;
1902         }
1903     }
1904     return len1 - len;
1905 }
1906
1907 static int win_chr_read_poll(WinCharState *s)
1908 {
1909     s->max_size = s->fd_can_read(s->win_opaque);
1910     return s->max_size;
1911 }
1912
1913 static void win_chr_readfile(WinCharState *s)
1914 {
1915     int ret, err;
1916     uint8_t buf[1024];
1917     DWORD size;
1918
1919     ZeroMemory(&s->orecv, sizeof(s->orecv));
1920     s->orecv.hEvent = s->hrecv;
1921     ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
1922     if (!ret) {
1923         err = GetLastError();
1924         if (err == ERROR_IO_PENDING) {
1925             ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
1926         }
1927     }
1928
1929     if (size > 0) {
1930         s->fd_read(s->win_opaque, buf, size);
1931     }
1932 }
1933
1934 static void win_chr_read(WinCharState *s)
1935 {
1936     if (s->len > s->max_size)
1937         s->len = s->max_size;
1938     if (s->len == 0)
1939         return;
1940
1941     win_chr_readfile(s);
1942 }
1943
1944 static int win_chr_poll(void *opaque)
1945 {
1946     WinCharState *s = opaque;
1947     COMSTAT status;
1948     DWORD comerr;
1949
1950     ClearCommError(s->hcom, &comerr, &status);
1951     if (status.cbInQue > 0) {
1952         s->len = status.cbInQue;
1953         win_chr_read_poll(s);
1954         win_chr_read(s);
1955         return 1;
1956     }
1957     return 0;
1958 }
1959
1960 static void win_chr_add_read_handler(CharDriverState *chr,
1961                                     IOCanRWHandler *fd_can_read,
1962                                     IOReadHandler *fd_read, void *opaque)
1963 {
1964     WinCharState *s = chr->opaque;
1965
1966     s->fd_can_read = fd_can_read;
1967     s->fd_read = fd_read;
1968     s->win_opaque = opaque;
1969 }
1970
1971 CharDriverState *qemu_chr_open_win(const char *filename)
1972 {
1973     CharDriverState *chr;
1974     WinCharState *s;
1975
1976     chr = qemu_mallocz(sizeof(CharDriverState));
1977     if (!chr)
1978         return NULL;
1979     s = qemu_mallocz(sizeof(WinCharState));
1980     if (!s) {
1981         free(chr);
1982         return NULL;
1983     }
1984     chr->opaque = s;
1985     chr->chr_write = win_chr_write;
1986     chr->chr_add_read_handler = win_chr_add_read_handler;
1987     chr->chr_close = win_chr_close;
1988
1989     if (win_chr_init(s, filename) < 0) {
1990         free(s);
1991         free(chr);
1992         return NULL;
1993     }
1994     return chr;
1995 }
1996
1997 static int win_chr_pipe_poll(void *opaque)
1998 {
1999     WinCharState *s = opaque;
2000     DWORD size;
2001
2002     PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2003     if (size > 0) {
2004         s->len = size;
2005         win_chr_read_poll(s);
2006         win_chr_read(s);
2007         return 1;
2008     }
2009     return 0;
2010 }
2011
2012 static int win_chr_pipe_init(WinCharState *s, const char *filename)
2013 {
2014     OVERLAPPED ov;
2015     int ret;
2016     DWORD size;
2017     char openname[256];
2018
2019     s->fpipe = TRUE;
2020
2021     s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2022     if (!s->hsend) {
2023         fprintf(stderr, "Failed CreateEvent\n");
2024         goto fail;
2025     }
2026     s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2027     if (!s->hrecv) {
2028         fprintf(stderr, "Failed CreateEvent\n");
2029         goto fail;
2030     }
2031
2032     snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2033     s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2034                               PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2035                               PIPE_WAIT,
2036                               MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2037     if (s->hcom == INVALID_HANDLE_VALUE) {
2038         fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2039         s->hcom = NULL;
2040         goto fail;
2041     }
2042
2043     ZeroMemory(&ov, sizeof(ov));
2044     ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2045     ret = ConnectNamedPipe(s->hcom, &ov);
2046     if (ret) {
2047         fprintf(stderr, "Failed ConnectNamedPipe\n");
2048         goto fail;
2049     }
2050
2051     ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2052     if (!ret) {
2053         fprintf(stderr, "Failed GetOverlappedResult\n");
2054         if (ov.hEvent) {
2055             CloseHandle(ov.hEvent);
2056             ov.hEvent = NULL;
2057         }
2058         goto fail;
2059     }
2060
2061     if (ov.hEvent) {
2062         CloseHandle(ov.hEvent);
2063         ov.hEvent = NULL;
2064     }
2065     qemu_add_polling_cb(win_chr_pipe_poll, s);
2066     return 0;
2067
2068  fail:
2069     win_chr_close2(s);
2070     return -1;
2071 }
2072
2073
2074 CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2075 {
2076     CharDriverState *chr;
2077     WinCharState *s;
2078
2079     chr = qemu_mallocz(sizeof(CharDriverState));
2080     if (!chr)
2081         return NULL;
2082     s = qemu_mallocz(sizeof(WinCharState));
2083     if (!s) {
2084         free(chr);
2085         return NULL;
2086     }
2087     chr->opaque = s;
2088     chr->chr_write = win_chr_write;
2089     chr->chr_add_read_handler = win_chr_add_read_handler;
2090     chr->chr_close = win_chr_close;
2091
2092     if (win_chr_pipe_init(s, filename) < 0) {
2093         free(s);
2094         free(chr);
2095         return NULL;
2096     }
2097     return chr;
2098 }
2099
2100 CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2101 {
2102     CharDriverState *chr;
2103     WinCharState *s;
2104
2105     chr = qemu_mallocz(sizeof(CharDriverState));
2106     if (!chr)
2107         return NULL;
2108     s = qemu_mallocz(sizeof(WinCharState));
2109     if (!s) {
2110         free(chr);
2111         return NULL;
2112     }
2113     s->hcom = fd_out;
2114     chr->opaque = s;
2115     chr->chr_write = win_chr_write;
2116     chr->chr_add_read_handler = win_chr_add_read_handler;
2117     return chr;
2118 }
2119
2120 CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2121 {
2122     HANDLE fd_out;
2123
2124     fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2125                         OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2126     if (fd_out == INVALID_HANDLE_VALUE)
2127         return NULL;
2128
2129     return qemu_chr_open_win_file(fd_out);
2130 }
2131 #endif
2132
2133 CharDriverState *qemu_chr_open(const char *filename)
2134 {
2135     const char *p;
2136
2137     if (!strcmp(filename, "vc")) {
2138         return text_console_init(&display_state);
2139     } else if (!strcmp(filename, "null")) {
2140         return qemu_chr_open_null();
2141     } else
2142 #ifndef _WIN32
2143     if (strstart(filename, "file:", &p)) {
2144         return qemu_chr_open_file_out(p);
2145     } else if (strstart(filename, "pipe:", &p)) {
2146         return qemu_chr_open_pipe(p);
2147     } else if (!strcmp(filename, "pty")) {
2148         return qemu_chr_open_pty();
2149     } else if (!strcmp(filename, "stdio")) {
2150         return qemu_chr_open_stdio();
2151     } else
2152 #endif
2153 #if defined(__linux__)
2154     if (strstart(filename, "/dev/parport", NULL)) {
2155         return qemu_chr_open_pp(filename);
2156     } else
2157     if (strstart(filename, "/dev/", NULL)) {
2158         return qemu_chr_open_tty(filename);
2159     } else
2160 #endif
2161 #ifdef _WIN32
2162     if (strstart(filename, "COM", NULL)) {
2163         return qemu_chr_open_win(filename);
2164     } else
2165     if (strstart(filename, "pipe:", &p)) {
2166         return qemu_chr_open_win_pipe(p);
2167     } else
2168     if (strstart(filename, "file:", &p)) {
2169         return qemu_chr_open_win_file_out(p);
2170     }
2171 #endif
2172     {
2173         return NULL;
2174     }
2175 }
2176
2177 void qemu_chr_close(CharDriverState *chr)
2178 {
2179     if (chr->chr_close)
2180         chr->chr_close(chr);
2181 }
2182
2183 /***********************************************************/
2184 /* network device redirectors */
2185
2186 void hex_dump(FILE *f, const uint8_t *buf, int size)
2187 {
2188     int len, i, j, c;
2189
2190     for(i=0;i<size;i+=16) {
2191         len = size - i;
2192         if (len > 16)
2193             len = 16;
2194         fprintf(f, "%08x ", i);
2195         for(j=0;j<16;j++) {
2196             if (j < len)
2197                 fprintf(f, " %02x", buf[i+j]);
2198             else
2199                 fprintf(f, "   ");
2200         }
2201         fprintf(f, " ");
2202         for(j=0;j<len;j++) {
2203             c = buf[i+j];
2204             if (c < ' ' || c > '~')
2205                 c = '.';
2206             fprintf(f, "%c", c);
2207         }
2208         fprintf(f, "\n");
2209     }
2210 }
2211
2212 static int parse_macaddr(uint8_t *macaddr, const char *p)
2213 {
2214     int i;
2215     for(i = 0; i < 6; i++) {
2216         macaddr[i] = strtol(p, (char **)&p, 16);
2217         if (i == 5) {
2218             if (*p != '\0')
2219                 return -1;
2220         } else {
2221             if (*p != ':')
2222                 return -1;
2223             p++;
2224         }
2225     }
2226     return 0;
2227 }
2228
2229 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
2230 {
2231     const char *p, *p1;
2232     int len;
2233     p = *pp;
2234     p1 = strchr(p, sep);
2235     if (!p1)
2236         return -1;
2237     len = p1 - p;
2238     p1++;
2239     if (buf_size > 0) {
2240         if (len > buf_size - 1)
2241             len = buf_size - 1;
2242         memcpy(buf, p, len);
2243         buf[len] = '\0';
2244     }
2245     *pp = p1;
2246     return 0;
2247 }
2248
2249 int parse_host_port(struct sockaddr_in *saddr, const char *str)
2250 {
2251     char buf[512];
2252     struct hostent *he;
2253     const char *p, *r;
2254     int port;
2255
2256     p = str;
2257     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2258         return -1;
2259     saddr->sin_family = AF_INET;
2260     if (buf[0] == '\0') {
2261         saddr->sin_addr.s_addr = 0;
2262     } else {
2263         if (isdigit(buf[0])) {
2264             if (!inet_aton(buf, &saddr->sin_addr))
2265                 return -1;
2266         } else {
2267             if ((he = gethostbyname(buf)) == NULL)
2268                 return - 1;
2269             saddr->sin_addr = *(struct in_addr *)he->h_addr;
2270         }
2271     }
2272     port = strtol(p, (char **)&r, 0);
2273     if (r == p)
2274         return -1;
2275     saddr->sin_port = htons(port);
2276     return 0;
2277 }
2278
2279 /* find or alloc a new VLAN */
2280 VLANState *qemu_find_vlan(int id)
2281 {
2282     VLANState **pvlan, *vlan;
2283     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2284         if (vlan->id == id)
2285             return vlan;
2286     }
2287     vlan = qemu_mallocz(sizeof(VLANState));
2288     if (!vlan)
2289         return NULL;
2290     vlan->id = id;
2291     vlan->next = NULL;
2292     pvlan = &first_vlan;
2293     while (*pvlan != NULL)
2294         pvlan = &(*pvlan)->next;
2295     *pvlan = vlan;
2296     return vlan;
2297 }
2298
2299 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
2300                                       IOReadHandler *fd_read,
2301                                       IOCanRWHandler *fd_can_read,
2302                                       void *opaque)
2303 {
2304     VLANClientState *vc, **pvc;
2305     vc = qemu_mallocz(sizeof(VLANClientState));
2306     if (!vc)
2307         return NULL;
2308     vc->fd_read = fd_read;
2309     vc->fd_can_read = fd_can_read;
2310     vc->opaque = opaque;
2311     vc->vlan = vlan;
2312
2313     vc->next = NULL;
2314     pvc = &vlan->first_client;
2315     while (*pvc != NULL)
2316         pvc = &(*pvc)->next;
2317     *pvc = vc;
2318     return vc;
2319 }
2320
2321 int qemu_can_send_packet(VLANClientState *vc1)
2322 {
2323     VLANState *vlan = vc1->vlan;
2324     VLANClientState *vc;
2325
2326     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2327         if (vc != vc1) {
2328             if (vc->fd_can_read && !vc->fd_can_read(vc->opaque))
2329                 return 0;
2330         }
2331     }
2332     return 1;
2333 }
2334
2335 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
2336 {
2337     VLANState *vlan = vc1->vlan;
2338     VLANClientState *vc;
2339
2340 #if 0
2341     printf("vlan %d send:\n", vlan->id);
2342     hex_dump(stdout, buf, size);
2343 #endif
2344     for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2345         if (vc != vc1) {
2346             vc->fd_read(vc->opaque, buf, size);
2347         }
2348     }
2349 }
2350
2351 #if defined(CONFIG_SLIRP)
2352
2353 /* slirp network adapter */
2354
2355 static int slirp_inited;
2356 static VLANClientState *slirp_vc;
2357
2358 int slirp_can_output(void)
2359 {
2360     return !slirp_vc || qemu_can_send_packet(slirp_vc);
2361 }
2362
2363 void slirp_output(const uint8_t *pkt, int pkt_len)
2364 {
2365 #if 0
2366     printf("slirp output:\n");
2367     hex_dump(stdout, pkt, pkt_len);
2368 #endif
2369     if (!slirp_vc)
2370         return;
2371     qemu_send_packet(slirp_vc, pkt, pkt_len);
2372 }
2373
2374 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
2375 {
2376 #if 0
2377     printf("slirp input:\n");
2378     hex_dump(stdout, buf, size);
2379 #endif
2380     slirp_input(buf, size);
2381 }
2382
2383 static int net_slirp_init(VLANState *vlan)
2384 {
2385     if (!slirp_inited) {
2386         slirp_inited = 1;
2387         slirp_init();
2388     }
2389     slirp_vc = qemu_new_vlan_client(vlan,
2390                                     slirp_receive, NULL, NULL);
2391     snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
2392     return 0;
2393 }
2394
2395 static void net_slirp_redir(const char *redir_str)
2396 {
2397     int is_udp;
2398     char buf[256], *r;
2399     const char *p;
2400     struct in_addr guest_addr;
2401     int host_port, guest_port;
2402
2403     if (!slirp_inited) {
2404         slirp_inited = 1;
2405         slirp_init();
2406     }
2407
2408     p = redir_str;
2409     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2410         goto fail;
2411     if (!strcmp(buf, "tcp")) {
2412         is_udp = 0;
2413     } else if (!strcmp(buf, "udp")) {
2414         is_udp = 1;
2415     } else {
2416         goto fail;
2417     }
2418
2419     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2420         goto fail;
2421     host_port = strtol(buf, &r, 0);
2422     if (r == buf)
2423         goto fail;
2424
2425     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2426         goto fail;
2427     if (buf[0] == '\0') {
2428         pstrcpy(buf, sizeof(buf), "10.0.2.15");
2429     }
2430     if (!inet_aton(buf, &guest_addr))
2431         goto fail;
2432
2433     guest_port = strtol(p, &r, 0);
2434     if (r == p)
2435         goto fail;
2436
2437     if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
2438         fprintf(stderr, "qemu: could not set up redirection\n");
2439         exit(1);
2440     }
2441     return;
2442  fail:
2443     fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
2444     exit(1);
2445 }
2446
2447 #ifndef _WIN32
2448
2449 char smb_dir[1024];
2450
2451 static void smb_exit(void)
2452 {
2453     DIR *d;
2454     struct dirent *de;
2455     char filename[1024];
2456
2457     /* erase all the files in the directory */
2458     d = opendir(smb_dir);
2459     for(;;) {
2460         de = readdir(d);
2461         if (!de)
2462             break;
2463         if (strcmp(de->d_name, ".") != 0 &&
2464             strcmp(de->d_name, "..") != 0) {
2465             snprintf(filename, sizeof(filename), "%s/%s",
2466                      smb_dir, de->d_name);
2467             unlink(filename);
2468         }
2469     }
2470     closedir(d);
2471     rmdir(smb_dir);
2472 }
2473
2474 /* automatic user mode samba server configuration */
2475 void net_slirp_smb(const char *exported_dir)
2476 {
2477     char smb_conf[1024];
2478     char smb_cmdline[1024];
2479     FILE *f;
2480
2481     if (!slirp_inited) {
2482         slirp_inited = 1;
2483         slirp_init();
2484     }
2485
2486     /* XXX: better tmp dir construction */
2487     snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
2488     if (mkdir(smb_dir, 0700) < 0) {
2489         fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
2490         exit(1);
2491     }
2492     snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
2493
2494     f = fopen(smb_conf, "w");
2495     if (!f) {
2496         fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
2497         exit(1);
2498     }
2499     fprintf(f,
2500             "[global]\n"
2501             "private dir=%s\n"
2502             "smb ports=0\n"
2503             "socket address=127.0.0.1\n"
2504             "pid directory=%s\n"
2505             "lock directory=%s\n"
2506             "log file=%s/log.smbd\n"
2507             "smb passwd file=%s/smbpasswd\n"
2508             "security = share\n"
2509             "[qemu]\n"
2510             "path=%s\n"
2511             "read only=no\n"
2512             "guest ok=yes\n",
2513             smb_dir,
2514             smb_dir,
2515             smb_dir,
2516             smb_dir,
2517             smb_dir,
2518             exported_dir
2519             );
2520     fclose(f);
2521     atexit(smb_exit);
2522
2523     snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
2524              smb_conf);
2525
2526     slirp_add_exec(0, smb_cmdline, 4, 139);
2527 }
2528
2529 #endif /* !defined(_WIN32) */
2530
2531 #endif /* CONFIG_SLIRP */
2532
2533 #if !defined(_WIN32)
2534
2535 typedef struct TAPState {
2536     VLANClientState *vc;
2537     int fd;
2538 } TAPState;
2539
2540 static void tap_receive(void *opaque, const uint8_t *buf, int size)
2541 {
2542     TAPState *s = opaque;
2543     int ret;
2544     for(;;) {
2545         ret = write(s->fd, buf, size);
2546         if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
2547         } else {
2548             break;
2549         }
2550     }
2551 }
2552
2553 static void tap_send(void *opaque)
2554 {
2555     TAPState *s = opaque;
2556     uint8_t buf[4096];
2557     int size;
2558
2559     size = read(s->fd, buf, sizeof(buf));
2560     if (size > 0) {
2561         qemu_send_packet(s->vc, buf, size);
2562     }
2563 }
2564
2565 /* fd support */
2566
2567 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
2568 {
2569     TAPState *s;
2570
2571     s = qemu_mallocz(sizeof(TAPState));
2572     if (!s)
2573         return NULL;
2574     s->fd = fd;
2575     s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
2576     qemu_set_fd_handler(s->fd, tap_send, NULL, s);
2577     snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
2578     return s;
2579 }
2580
2581 #ifdef _BSD
2582 static int tap_open(char *ifname, int ifname_size)
2583 {
2584     int fd;
2585     char *dev;
2586     struct stat s;
2587
2588     fd = open("/dev/tap", O_RDWR);
2589     if (fd < 0) {
2590         fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
2591         return -1;
2592     }
2593
2594     fstat(fd, &s);
2595     dev = devname(s.st_rdev, S_IFCHR);
2596     pstrcpy(ifname, ifname_size, dev);
2597
2598     fcntl(fd, F_SETFL, O_NONBLOCK);
2599     return fd;
2600 }
2601 #elif defined(__sun__)
2602 static int tap_open(char *ifname, int ifname_size)
2603 {
2604     fprintf(stderr, "warning: tap_open not yet implemented\n");
2605     return -1;
2606 }
2607 #else
2608 static int tap_open(char *ifname, int ifname_size)
2609 {
2610     struct ifreq ifr;
2611     int fd, ret;
2612
2613     fd = open("/dev/net/tun", O_RDWR);
2614     if (fd < 0) {
2615         fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
2616         return -1;
2617     }
2618     memset(&ifr, 0, sizeof(ifr));
2619     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
2620     if (ifname[0] != '\0')
2621         pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
2622     else
2623         pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
2624     ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
2625     if (ret != 0) {
2626         fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
2627         close(fd);
2628         return -1;
2629     }
2630     pstrcpy(ifname, ifname_size, ifr.ifr_name);
2631     fcntl(fd, F_SETFL, O_NONBLOCK);
2632     return fd;
2633 }
2634 #endif
2635
2636 static int net_tap_init(VLANState *vlan, const char *ifname1,
2637                         const char *setup_script)
2638 {
2639     TAPState *s;
2640     int pid, status, fd;
2641     char *args[3];
2642     char **parg;
2643     char ifname[128];
2644
2645     if (ifname1 != NULL)
2646         pstrcpy(ifname, sizeof(ifname), ifname1);
2647     else
2648         ifname[0] = '\0';
2649     fd = tap_open(ifname, sizeof(ifname));
2650     if (fd < 0)
2651         return -1;
2652
2653     if (!setup_script)
2654         setup_script = "";
2655     if (setup_script[0] != '\0') {
2656         /* try to launch network init script */
2657         pid = fork();
2658         if (pid >= 0) {
2659             if (pid == 0) {
2660                 parg = args;
2661                 *parg++ = (char *)setup_script;
2662                 *parg++ = ifname;
2663                 *parg++ = NULL;
2664                 execv(setup_script, args);
2665                 _exit(1);
2666             }
2667             while (waitpid(pid, &status, 0) != pid);
2668             if (!WIFEXITED(status) ||
2669                 WEXITSTATUS(status) != 0) {
2670                 fprintf(stderr, "%s: could not launch network script\n",
2671                         setup_script);
2672                 return -1;
2673             }
2674         }
2675     }
2676     s = net_tap_fd_init(vlan, fd);
2677     if (!s)
2678         return -1;
2679     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2680              "tap: ifname=%s setup_script=%s", ifname, setup_script);
2681     return 0;
2682 }
2683
2684 #endif /* !_WIN32 */
2685
2686 /* network connection */
2687 typedef struct NetSocketState {
2688     VLANClientState *vc;
2689     int fd;
2690     int state; /* 0 = getting length, 1 = getting data */
2691     int index;
2692     int packet_len;
2693     uint8_t buf[4096];
2694     struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
2695 } NetSocketState;
2696
2697 typedef struct NetSocketListenState {
2698     VLANState *vlan;
2699     int fd;
2700 } NetSocketListenState;
2701
2702 /* XXX: we consider we can send the whole packet without blocking */
2703 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
2704 {
2705     NetSocketState *s = opaque;
2706     uint32_t len;
2707     len = htonl(size);
2708
2709     send_all(s->fd, (const uint8_t *)&len, sizeof(len));
2710     send_all(s->fd, buf, size);
2711 }
2712
2713 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
2714 {
2715     NetSocketState *s = opaque;
2716     sendto(s->fd, buf, size, 0,
2717            (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
2718 }
2719
2720 static void net_socket_send(void *opaque)
2721 {
2722     NetSocketState *s = opaque;
2723     int l, size, err;
2724     uint8_t buf1[4096];
2725     const uint8_t *buf;
2726
2727     size = recv(s->fd, buf1, sizeof(buf1), 0);
2728     if (size < 0) {
2729         err = socket_error();
2730         if (err != EWOULDBLOCK)
2731             goto eoc;
2732     } else if (size == 0) {
2733         /* end of connection */
2734     eoc:
2735         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2736         closesocket(s->fd);
2737         return;
2738     }
2739     buf = buf1;
2740     while (size > 0) {
2741         /* reassemble a packet from the network */
2742         switch(s->state) {
2743         case 0:
2744             l = 4 - s->index;
2745             if (l > size)
2746                 l = size;
2747             memcpy(s->buf + s->index, buf, l);
2748             buf += l;
2749             size -= l;
2750             s->index += l;
2751             if (s->index == 4) {
2752                 /* got length */
2753                 s->packet_len = ntohl(*(uint32_t *)s->buf);
2754                 s->index = 0;
2755                 s->state = 1;
2756             }
2757             break;
2758         case 1:
2759             l = s->packet_len - s->index;
2760             if (l > size)
2761                 l = size;
2762             memcpy(s->buf + s->index, buf, l);
2763             s->index += l;
2764             buf += l;
2765             size -= l;
2766             if (s->index >= s->packet_len) {
2767                 qemu_send_packet(s->vc, s->buf, s->packet_len);
2768                 s->index = 0;
2769                 s->state = 0;
2770             }
2771             break;
2772         }
2773     }
2774 }
2775
2776 static void net_socket_send_dgram(void *opaque)
2777 {
2778     NetSocketState *s = opaque;
2779     int size;
2780
2781     size = recv(s->fd, s->buf, sizeof(s->buf), 0);
2782     if (size < 0)
2783         return;
2784     if (size == 0) {
2785         /* end of connection */
2786         qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2787         return;
2788     }
2789     qemu_send_packet(s->vc, s->buf, size);
2790 }
2791
2792 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
2793 {
2794     struct ip_mreq imr;
2795     int fd;
2796     int val, ret;
2797     if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
2798         fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
2799                 inet_ntoa(mcastaddr->sin_addr),
2800                 (int)ntohl(mcastaddr->sin_addr.s_addr));
2801         return -1;
2802
2803     }
2804     fd = socket(PF_INET, SOCK_DGRAM, 0);
2805     if (fd < 0) {
2806         perror("socket(PF_INET, SOCK_DGRAM)");
2807         return -1;
2808     }
2809
2810     val = 1;
2811     ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2812                    (const char *)&val, sizeof(val));
2813     if (ret < 0) {
2814         perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
2815         goto fail;
2816     }
2817
2818     ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
2819     if (ret < 0) {
2820         perror("bind");
2821         goto fail;
2822     }
2823
2824     /* Add host to multicast group */
2825     imr.imr_multiaddr = mcastaddr->sin_addr;
2826     imr.imr_interface.s_addr = htonl(INADDR_ANY);
2827
2828     ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
2829                      (const char *)&imr, sizeof(struct ip_mreq));
2830     if (ret < 0) {
2831         perror("setsockopt(IP_ADD_MEMBERSHIP)");
2832         goto fail;
2833     }
2834
2835     /* Force mcast msgs to loopback (eg. several QEMUs in same host */
2836     val = 1;
2837     ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
2838                    (const char *)&val, sizeof(val));
2839     if (ret < 0) {
2840         perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
2841         goto fail;
2842     }
2843
2844     socket_set_nonblock(fd);
2845     return fd;
2846 fail:
2847     if (fd>=0) close(fd);
2848     return -1;
2849 }
2850
2851 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
2852                                           int is_connected)
2853 {
2854     struct sockaddr_in saddr;
2855     int newfd;
2856     socklen_t saddr_len;
2857     NetSocketState *s;
2858
2859     /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
2860      * Because this may be "shared" socket from a "master" process, datagrams would be recv()
2861      * by ONLY ONE process: we must "clone" this dgram socket --jjo
2862      */
2863
2864     if (is_connected) {
2865         if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
2866             /* must be bound */
2867             if (saddr.sin_addr.s_addr==0) {
2868                 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
2869                         fd);
2870                 return NULL;
2871             }
2872             /* clone dgram socket */
2873             newfd = net_socket_mcast_create(&saddr);
2874             if (newfd < 0) {
2875                 /* error already reported by net_socket_mcast_create() */
2876                 close(fd);
2877                 return NULL;
2878             }
2879             /* clone newfd to fd, close newfd */
2880             dup2(newfd, fd);
2881             close(newfd);
2882
2883         } else {
2884             fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2885                     fd, strerror(errno));
2886             return NULL;
2887         }
2888     }
2889
2890     s = qemu_mallocz(sizeof(NetSocketState));
2891     if (!s)
2892         return NULL;
2893     s->fd = fd;
2894
2895     s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
2896     qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2897
2898     /* mcast: save bound address as dst */
2899     if (is_connected) s->dgram_dst=saddr;
2900
2901     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2902             "socket: fd=%d (%s mcast=%s:%d)",
2903             fd, is_connected? "cloned" : "",
2904             inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2905     return s;
2906 }
2907
2908 static void net_socket_connect(void *opaque)
2909 {
2910     NetSocketState *s = opaque;
2911     qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2912 }
2913
2914 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
2915                                           int is_connected)
2916 {
2917     NetSocketState *s;
2918     s = qemu_mallocz(sizeof(NetSocketState));
2919     if (!s)
2920         return NULL;
2921     s->fd = fd;
2922     s->vc = qemu_new_vlan_client(vlan,
2923                                  net_socket_receive, NULL, s);
2924     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2925              "socket: fd=%d", fd);
2926     if (is_connected) {
2927         net_socket_connect(s);
2928     } else {
2929         qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2930     }
2931     return s;
2932 }
2933
2934 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
2935                                           int is_connected)
2936 {
2937     int so_type=-1, optlen=sizeof(so_type);
2938
2939     if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
2940         fprintf(stderr, "qemu: error: setsockopt(SO_TYPE) for fd=%d failed\n", fd);
2941         return NULL;
2942     }
2943     switch(so_type) {
2944     case SOCK_DGRAM:
2945         return net_socket_fd_init_dgram(vlan, fd, is_connected);
2946     case SOCK_STREAM:
2947         return net_socket_fd_init_stream(vlan, fd, is_connected);
2948     default:
2949         /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2950         fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2951         return net_socket_fd_init_stream(vlan, fd, is_connected);
2952     }
2953     return NULL;
2954 }
2955
2956 static void net_socket_accept(void *opaque)
2957 {
2958     NetSocketListenState *s = opaque;
2959     NetSocketState *s1;
2960     struct sockaddr_in saddr;
2961     socklen_t len;
2962     int fd;
2963
2964     for(;;) {
2965         len = sizeof(saddr);
2966         fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2967         if (fd < 0 && errno != EINTR) {
2968             return;
2969         } else if (fd >= 0) {
2970             break;
2971         }
2972     }
2973     s1 = net_socket_fd_init(s->vlan, fd, 1);
2974     if (!s1) {
2975         close(fd);
2976     } else {
2977         snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2978                  "socket: connection from %s:%d",
2979                  inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2980     }
2981 }
2982
2983 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
2984 {
2985     NetSocketListenState *s;
2986     int fd, val, ret;
2987     struct sockaddr_in saddr;
2988
2989     if (parse_host_port(&saddr, host_str) < 0)
2990         return -1;
2991
2992     s = qemu_mallocz(sizeof(NetSocketListenState));
2993     if (!s)
2994         return -1;
2995
2996     fd = socket(PF_INET, SOCK_STREAM, 0);
2997     if (fd < 0) {
2998         perror("socket");
2999         return -1;
3000     }
3001     socket_set_nonblock(fd);
3002
3003     /* allow fast reuse */
3004     val = 1;
3005     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3006
3007     ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3008     if (ret < 0) {
3009         perror("bind");
3010         return -1;
3011     }
3012     ret = listen(fd, 0);
3013     if (ret < 0) {
3014         perror("listen");
3015         return -1;
3016     }
3017     s->vlan = vlan;
3018     s->fd = fd;
3019     qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
3020     return 0;
3021 }
3022
3023 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
3024 {
3025     NetSocketState *s;
3026     int fd, connected, ret, err;
3027     struct sockaddr_in saddr;
3028
3029     if (parse_host_port(&saddr, host_str) < 0)
3030         return -1;
3031
3032     fd = socket(PF_INET, SOCK_STREAM, 0);
3033     if (fd < 0) {
3034         perror("socket");
3035         return -1;
3036     }
3037     socket_set_nonblock(fd);
3038
3039     connected = 0;
3040     for(;;) {
3041         ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3042         if (ret < 0) {
3043             err = socket_error();
3044             if (err == EINTR || err == EWOULDBLOCK) {
3045             } else if (err == EINPROGRESS) {
3046                 break;
3047             } else {
3048                 perror("connect");
3049                 closesocket(fd);
3050                 return -1;
3051             }
3052         } else {
3053             connected = 1;
3054             break;
3055         }
3056     }
3057     s = net_socket_fd_init(vlan, fd, connected);
3058     if (!s)
3059         return -1;
3060     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3061              "socket: connect to %s:%d",
3062              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3063     return 0;
3064 }
3065
3066 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
3067 {
3068     NetSocketState *s;
3069     int fd;
3070     struct sockaddr_in saddr;
3071
3072     if (parse_host_port(&saddr, host_str) < 0)
3073         return -1;
3074
3075
3076     fd = net_socket_mcast_create(&saddr);
3077     if (fd < 0)
3078         return -1;
3079
3080     s = net_socket_fd_init(vlan, fd, 0);
3081     if (!s)
3082         return -1;
3083
3084     s->dgram_dst = saddr;
3085
3086     snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3087              "socket: mcast=%s:%d",
3088              inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3089     return 0;
3090
3091 }
3092
3093 static int get_param_value(char *buf, int buf_size,
3094                            const char *tag, const char *str)
3095 {
3096     const char *p;
3097     char *q;
3098     char option[128];
3099
3100     p = str;
3101     for(;;) {
3102         q = option;
3103         while (*p != '\0' && *p != '=') {
3104             if ((q - option) < sizeof(option) - 1)
3105                 *q++ = *p;
3106             p++;
3107         }
3108         *q = '\0';
3109         if (*p != '=')
3110             break;
3111         p++;
3112         if (!strcmp(tag, option)) {
3113             q = buf;
3114             while (*p != '\0' && *p != ',') {
3115                 if ((q - buf) < buf_size - 1)
3116                     *q++ = *p;
3117                 p++;
3118             }
3119             *q = '\0';
3120             return q - buf;
3121         } else {
3122             while (*p != '\0' && *p != ',') {
3123                 p++;
3124             }
3125         }
3126         if (*p != ',')
3127             break;
3128         p++;
3129     }
3130     return 0;
3131 }
3132
3133 int net_client_init(const char *str)
3134 {
3135     const char *p;
3136     char *q;
3137     char device[64];
3138     char buf[1024];
3139     int vlan_id, ret;
3140     VLANState *vlan;
3141
3142     p = str;
3143     q = device;
3144     while (*p != '\0' && *p != ',') {
3145         if ((q - device) < sizeof(device) - 1)
3146             *q++ = *p;
3147         p++;
3148     }
3149     *q = '\0';
3150     if (*p == ',')
3151         p++;
3152     vlan_id = 0;
3153     if (get_param_value(buf, sizeof(buf), "vlan", p)) {
3154         vlan_id = strtol(buf, NULL, 0);
3155     }
3156     vlan = qemu_find_vlan(vlan_id);
3157     if (!vlan) {
3158         fprintf(stderr, "Could not create vlan %d\n", vlan_id);
3159         return -1;
3160     }
3161     if (!strcmp(device, "nic")) {
3162         NICInfo *nd;
3163         uint8_t *macaddr;
3164
3165         if (nb_nics >= MAX_NICS) {
3166             fprintf(stderr, "Too Many NICs\n");
3167             return -1;
3168         }
3169         nd = &nd_table[nb_nics];
3170         macaddr = nd->macaddr;
3171         macaddr[0] = 0x52;
3172         macaddr[1] = 0x54;
3173         macaddr[2] = 0x00;
3174         macaddr[3] = 0x12;
3175         macaddr[4] = 0x34;
3176         macaddr[5] = 0x56 + nb_nics;
3177
3178         if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
3179             if (parse_macaddr(macaddr, buf) < 0) {
3180                 fprintf(stderr, "invalid syntax for ethernet address\n");
3181                 return -1;
3182             }
3183         }
3184         if (get_param_value(buf, sizeof(buf), "model", p)) {
3185             nd->model = strdup(buf);
3186         }
3187         nd->vlan = vlan;
3188         nb_nics++;
3189         ret = 0;
3190     } else
3191     if (!strcmp(device, "none")) {
3192         /* does nothing. It is needed to signal that no network cards
3193            are wanted */
3194         ret = 0;
3195     } else
3196 #ifdef CONFIG_SLIRP
3197     if (!strcmp(device, "user")) {
3198         if (get_param_value(buf, sizeof(buf), "hostname", p)) {
3199             pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
3200         }
3201         ret = net_slirp_init(vlan);
3202     } else
3203 #endif
3204 #ifdef _WIN32
3205     if (!strcmp(device, "tap")) {
3206         char ifname[64];
3207         if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
3208             fprintf(stderr, "tap: no interface name\n");
3209             return -1;
3210         }
3211         ret = tap_win32_init(vlan, ifname);
3212     } else
3213 #else
3214     if (!strcmp(device, "tap")) {
3215         char ifname[64];
3216         char setup_script[1024];
3217         int fd;
3218         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3219             fd = strtol(buf, NULL, 0);
3220             ret = -1;
3221             if (net_tap_fd_init(vlan, fd))
3222                 ret = 0;
3223         } else {
3224             get_param_value(ifname, sizeof(ifname), "ifname", p);
3225             if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
3226                 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
3227             }
3228             ret = net_tap_init(vlan, ifname, setup_script);
3229         }
3230     } else
3231 #endif
3232     if (!strcmp(device, "socket")) {
3233         if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3234             int fd;
3235             fd = strtol(buf, NULL, 0);
3236             ret = -1;
3237             if (net_socket_fd_init(vlan, fd, 1))
3238                 ret = 0;
3239         } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
3240             ret = net_socket_listen_init(vlan, buf);
3241         } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
3242             ret = net_socket_connect_init(vlan, buf);
3243         } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
3244             ret = net_socket_mcast_init(vlan, buf);
3245         } else {
3246             fprintf(stderr, "Unknown socket options: %s\n", p);
3247             return -1;
3248         }
3249     } else
3250     {
3251         fprintf(stderr, "Unknown network device: %s\n", device);
3252         return -1;
3253     }
3254     if (ret < 0) {
3255         fprintf(stderr, "Could not initialize device '%s'\n", device);
3256     }
3257
3258     return ret;
3259 }
3260
3261 void do_info_network(void)
3262 {
3263     VLANState *vlan;
3264     VLANClientState *vc;
3265
3266     for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3267         term_printf("VLAN %d devices:\n", vlan->id);
3268         for(vc = vlan->first_client; vc != NULL; vc = vc->next)
3269             term_printf("  %s\n", vc->info_str);
3270     }
3271 }
3272
3273 /***********************************************************/
3274 /* USB devices */
3275
3276 static USBPort *used_usb_ports;
3277 static USBPort *free_usb_ports;
3278
3279 /* ??? Maybe change this to register a hub to keep track of the topology.  */
3280 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
3281                             usb_attachfn attach)
3282 {
3283     port->opaque = opaque;
3284     port->index = index;
3285     port->attach = attach;
3286     port->next = free_usb_ports;
3287     free_usb_ports = port;
3288 }
3289
3290 static int usb_device_add(const char *devname)
3291 {
3292     const char *p;
3293     USBDevice *dev;
3294     USBPort *port;
3295
3296     if (!free_usb_ports)
3297         return -1;
3298
3299     if (strstart(devname, "host:", &p)) {
3300         dev = usb_host_device_open(p);
3301     } else if (!strcmp(devname, "mouse")) {
3302         dev = usb_mouse_init();
3303     } else if (!strcmp(devname, "tablet")) {
3304         dev = usb_tablet_init();
3305     } else if (strstart(devname, "disk:", &p)) {
3306         dev = usb_msd_init(p);
3307     } else {
3308         return -1;
3309     }
3310     if (!dev)
3311         return -1;
3312
3313     /* Find a USB port to add the device to.  */
3314     port = free_usb_ports;
3315     if (!port->next) {
3316         USBDevice *hub;
3317
3318         /* Create a new hub and chain it on.  */
3319         free_usb_ports = NULL;
3320         port->next = used_usb_ports;
3321         used_usb_ports = port;
3322
3323         hub = usb_hub_init(VM_USB_HUB_SIZE);
3324         usb_attach(port, hub);
3325         port = free_usb_ports;
3326     }
3327
3328     free_usb_ports = port->next;
3329     port->next = used_usb_ports;
3330     used_usb_ports = port;
3331     usb_attach(port, dev);
3332     return 0;
3333 }
3334
3335 static int usb_device_del(const char *devname)
3336 {
3337     USBPort *port;
3338     USBPort **lastp;
3339     int bus_num, addr;
3340     const char *p;
3341
3342     if (!used_usb_ports)
3343         return -1;
3344
3345     p = strchr(devname, '.');
3346     if (!p)
3347         return -1;
3348     bus_num = strtoul(devname, NULL, 0);
3349     addr = strtoul(p + 1, NULL, 0);
3350     if (bus_num != 0)
3351         return -1;
3352
3353     lastp = &used_usb_ports;
3354     port = used_usb_ports;
3355     while (port && port->dev->addr != addr) {
3356         lastp = &port->next;
3357         port = port->next;
3358     }
3359
3360     if (!port)
3361         return -1;
3362
3363     *lastp = port->next;
3364     usb_attach(port, NULL);
3365     port->next = free_usb_ports;
3366     free_usb_ports = port;
3367     return 0;
3368 }
3369
3370 void do_usb_add(const char *devname)
3371 {
3372     int ret;
3373     ret = usb_device_add(devname);
3374     if (ret < 0)
3375         term_printf("Could not add USB device '%s'\n", devname);
3376 }
3377
3378 void do_usb_del(const char *devname)
3379 {
3380     int ret;
3381     ret = usb_device_del(devname);
3382     if (ret < 0)
3383         term_printf("Could not remove USB device '%s'\n", devname);
3384 }
3385
3386 void usb_info(void)
3387 {
3388     USBDevice *dev;
3389     USBPort *port;
3390     const char *speed_str;
3391
3392     if (!usb_enabled) {
3393         term_printf("USB support not enabled\n");
3394         return;
3395     }
3396
3397     for (port = used_usb_ports; port; port = port->next) {
3398         dev = port->dev;
3399         if (!dev)
3400             continue;
3401         switch(dev->speed) {
3402         case USB_SPEED_LOW:
3403             speed_str = "1.5";
3404             break;
3405         case USB_SPEED_FULL:
3406             speed_str = "12";
3407             break;
3408         case USB_SPEED_HIGH:
3409             speed_str = "480";
3410             break;
3411         default:
3412             speed_str = "?";
3413             break;
3414         }
3415         term_printf("  Device %d.%d, speed %s Mb/s\n",
3416                     0, dev->addr, speed_str);
3417     }
3418 }
3419
3420 /***********************************************************/
3421 /* pid file */
3422
3423 static char *pid_filename;
3424
3425 /* Remove PID file. Called on normal exit */
3426
3427 static void remove_pidfile(void)
3428 {
3429     unlink (pid_filename);
3430 }
3431
3432 static void create_pidfile(const char *filename)
3433 {
3434     struct stat pidstat;
3435     FILE *f;
3436
3437     /* Try to write our PID to the named file */
3438     if (stat(filename, &pidstat) < 0) {
3439         if (errno == ENOENT) {
3440             if ((f = fopen (filename, "w")) == NULL) {
3441                 perror("Opening pidfile");
3442                 exit(1);
3443             }
3444             fprintf(f, "%d\n", getpid());
3445             fclose(f);
3446             pid_filename = qemu_strdup(filename);
3447             if (!pid_filename) {
3448                 fprintf(stderr, "Could not save PID filename");
3449                 exit(1);
3450             }
3451             atexit(remove_pidfile);
3452         }
3453     } else {
3454         fprintf(stderr, "%s already exists. Remove it and try again.\n",
3455                 filename);
3456         exit(1);
3457     }
3458 }
3459
3460 /***********************************************************/
3461 /* dumb display */
3462
3463 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
3464 {
3465 }
3466
3467 static void dumb_resize(DisplayState *ds, int w, int h)
3468 {
3469 }
3470
3471 static void dumb_refresh(DisplayState *ds)
3472 {
3473     vga_hw_update();
3474 }
3475
3476 void dumb_display_init(DisplayState *ds)
3477 {
3478     ds->data = NULL;
3479     ds->linesize = 0;
3480     ds->depth = 0;
3481     ds->dpy_update = dumb_update;
3482     ds->dpy_resize = dumb_resize;
3483     ds->dpy_refresh = dumb_refresh;
3484 }
3485
3486 #if !defined(CONFIG_SOFTMMU)
3487 /***********************************************************/
3488 /* cpu signal handler */
3489 static void host_segv_handler(int host_signum, siginfo_t *info,
3490                               void *puc)
3491 {
3492     if (cpu_signal_handler(host_signum, info, puc))
3493         return;
3494     if (stdio_nb_clients > 0)
3495         term_exit();
3496     abort();
3497 }
3498 #endif
3499
3500 /***********************************************************/
3501 /* I/O handling */
3502
3503 #define MAX_IO_HANDLERS 64
3504
3505 typedef struct IOHandlerRecord {
3506     int fd;
3507     IOCanRWHandler *fd_read_poll;
3508     IOHandler *fd_read;
3509     IOHandler *fd_write;
3510     void *opaque;
3511     /* temporary data */
3512     struct pollfd *ufd;
3513     struct IOHandlerRecord *next;
3514 } IOHandlerRecord;
3515
3516 static IOHandlerRecord *first_io_handler;
3517
3518 /* XXX: fd_read_poll should be suppressed, but an API change is
3519    necessary in the character devices to suppress fd_can_read(). */
3520 int qemu_set_fd_handler2(int fd,
3521                          IOCanRWHandler *fd_read_poll,
3522                          IOHandler *fd_read,
3523                          IOHandler *fd_write,
3524                          void *opaque)
3525 {
3526     IOHandlerRecord **pioh, *ioh;
3527
3528     if (!fd_read && !fd_write) {
3529         pioh = &first_io_handler;
3530         for(;;) {
3531             ioh = *pioh;
3532             if (ioh == NULL)
3533                 break;
3534             if (ioh->fd == fd) {
3535                 *pioh = ioh->next;
3536                 qemu_free(ioh);
3537                 break;
3538             }
3539             pioh = &ioh->next;
3540         }
3541     } else {
3542         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3543             if (ioh->fd == fd)
3544                 goto found;
3545         }
3546         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
3547         if (!ioh)
3548             return -1;
3549         ioh->next = first_io_handler;
3550         first_io_handler = ioh;
3551     found:
3552         ioh->fd = fd;
3553         ioh->fd_read_poll = fd_read_poll;
3554         ioh->fd_read = fd_read;
3555         ioh->fd_write = fd_write;
3556         ioh->opaque = opaque;
3557     }
3558     return 0;
3559 }
3560
3561 int qemu_set_fd_handler(int fd,
3562                         IOHandler *fd_read,
3563                         IOHandler *fd_write,
3564                         void *opaque)
3565 {
3566     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
3567 }
3568
3569 /***********************************************************/
3570 /* Polling handling */
3571
3572 typedef struct PollingEntry {
3573     PollingFunc *func;
3574     void *opaque;
3575     struct PollingEntry *next;
3576 } PollingEntry;
3577
3578 static PollingEntry *first_polling_entry;
3579
3580 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
3581 {
3582     PollingEntry **ppe, *pe;
3583     pe = qemu_mallocz(sizeof(PollingEntry));
3584     if (!pe)
3585         return -1;
3586     pe->func = func;
3587     pe->opaque = opaque;
3588     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
3589     *ppe = pe;
3590     return 0;
3591 }
3592
3593 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
3594 {
3595     PollingEntry **ppe, *pe;
3596     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
3597         pe = *ppe;
3598         if (pe->func == func && pe->opaque == opaque) {
3599             *ppe = pe->next;
3600             qemu_free(pe);
3601             break;
3602         }
3603     }
3604 }
3605
3606 /***********************************************************/
3607 /* savevm/loadvm support */
3608
3609 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
3610 {
3611     fwrite(buf, 1, size, f);
3612 }
3613
3614 void qemu_put_byte(QEMUFile *f, int v)
3615 {
3616     fputc(v, f);
3617 }
3618
3619 void qemu_put_be16(QEMUFile *f, unsigned int v)
3620 {
3621     qemu_put_byte(f, v >> 8);
3622     qemu_put_byte(f, v);
3623 }
3624
3625 void qemu_put_be32(QEMUFile *f, unsigned int v)
3626 {
3627     qemu_put_byte(f, v >> 24);
3628     qemu_put_byte(f, v >> 16);
3629     qemu_put_byte(f, v >> 8);
3630     qemu_put_byte(f, v);
3631 }
3632
3633 void qemu_put_be64(QEMUFile *f, uint64_t v)
3634 {
3635     qemu_put_be32(f, v >> 32);
3636     qemu_put_be32(f, v);
3637 }
3638
3639 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
3640 {
3641     return fread(buf, 1, size, f);
3642 }
3643
3644 int qemu_get_byte(QEMUFile *f)
3645 {
3646     int v;
3647     v = fgetc(f);
3648     if (v == EOF)
3649         return 0;
3650     else
3651         return v;
3652 }
3653
3654 unsigned int qemu_get_be16(QEMUFile *f)
3655 {
3656     unsigned int v;
3657     v = qemu_get_byte(f) << 8;
3658     v |= qemu_get_byte(f);
3659     return v;
3660 }
3661
3662 unsigned int qemu_get_be32(QEMUFile *f)
3663 {
3664     unsigned int v;
3665     v = qemu_get_byte(f) << 24;
3666     v |= qemu_get_byte(f) << 16;
3667     v |= qemu_get_byte(f) << 8;
3668     v |= qemu_get_byte(f);
3669     return v;
3670 }
3671
3672 uint64_t qemu_get_be64(QEMUFile *f)
3673 {
3674     uint64_t v;
3675     v = (uint64_t)qemu_get_be32(f) << 32;
3676     v |= qemu_get_be32(f);
3677     return v;
3678 }
3679
3680 int64_t qemu_ftell(QEMUFile *f)
3681 {
3682     return ftell(f);
3683 }
3684
3685 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
3686 {
3687     if (fseek(f, pos, whence) < 0)
3688         return -1;
3689     return ftell(f);
3690 }
3691
3692 typedef struct SaveStateEntry {
3693     char idstr[256];
3694     int instance_id;
3695     int version_id;
3696     SaveStateHandler *save_state;
3697     LoadStateHandler *load_state;
3698     void *opaque;
3699     struct SaveStateEntry *next;
3700 } SaveStateEntry;
3701
3702 static SaveStateEntry *first_se;
3703
3704 int register_savevm(const char *idstr,
3705                     int instance_id,
3706                     int version_id,
3707                     SaveStateHandler *save_state,
3708                     LoadStateHandler *load_state,
3709                     void *opaque)
3710 {
3711     SaveStateEntry *se, **pse;
3712
3713     se = qemu_malloc(sizeof(SaveStateEntry));
3714     if (!se)
3715         return -1;
3716     pstrcpy(se->idstr, sizeof(se->idstr), idstr);
3717     se->instance_id = instance_id;
3718     se->version_id = version_id;
3719     se->save_state = save_state;
3720     se->load_state = load_state;
3721     se->opaque = opaque;
3722     se->next = NULL;
3723
3724     /* add at the end of list */
3725     pse = &first_se;
3726     while (*pse != NULL)
3727         pse = &(*pse)->next;
3728     *pse = se;
3729     return 0;
3730 }
3731
3732 #define QEMU_VM_FILE_MAGIC   0x5145564d
3733 #define QEMU_VM_FILE_VERSION 0x00000001
3734
3735 int qemu_savevm(const char *filename)
3736 {
3737     SaveStateEntry *se;
3738     QEMUFile *f;
3739     int len, len_pos, cur_pos, saved_vm_running, ret;
3740
3741     saved_vm_running = vm_running;
3742     vm_stop(0);
3743
3744     f = fopen(filename, "wb");
3745     if (!f) {
3746         ret = -1;
3747         goto the_end;
3748     }
3749
3750     qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
3751     qemu_put_be32(f, QEMU_VM_FILE_VERSION);
3752
3753     for(se = first_se; se != NULL; se = se->next) {
3754         /* ID string */
3755         len = strlen(se->idstr);
3756         qemu_put_byte(f, len);
3757         qemu_put_buffer(f, se->idstr, len);
3758
3759         qemu_put_be32(f, se->instance_id);
3760         qemu_put_be32(f, se->version_id);
3761
3762         /* record size: filled later */
3763         len_pos = ftell(f);
3764         qemu_put_be32(f, 0);
3765
3766         se->save_state(f, se->opaque);
3767
3768         /* fill record size */
3769         cur_pos = ftell(f);
3770         len = ftell(f) - len_pos - 4;
3771         fseek(f, len_pos, SEEK_SET);
3772         qemu_put_be32(f, len);
3773         fseek(f, cur_pos, SEEK_SET);
3774     }
3775
3776     fclose(f);
3777     ret = 0;
3778  the_end:
3779     if (saved_vm_running)
3780         vm_start();
3781     return ret;
3782 }
3783
3784 static SaveStateEntry *find_se(const char *idstr, int instance_id)
3785 {
3786     SaveStateEntry *se;
3787
3788     for(se = first_se; se != NULL; se = se->next) {
3789         if (!strcmp(se->idstr, idstr) &&
3790             instance_id == se->instance_id)
3791             return se;
3792     }
3793     return NULL;
3794 }
3795
3796 int qemu_loadvm(const char *filename)
3797 {
3798     SaveStateEntry *se;
3799     QEMUFile *f;
3800     int len, cur_pos, ret, instance_id, record_len, version_id;
3801     int saved_vm_running;
3802     unsigned int v;
3803     char idstr[256];
3804
3805     saved_vm_running = vm_running;
3806     vm_stop(0);
3807
3808     f = fopen(filename, "rb");
3809     if (!f) {
3810         ret = -1;
3811         goto the_end;
3812     }
3813
3814     v = qemu_get_be32(f);
3815     if (v != QEMU_VM_FILE_MAGIC)
3816         goto fail;
3817     v = qemu_get_be32(f);
3818     if (v != QEMU_VM_FILE_VERSION) {
3819     fail:
3820         fclose(f);
3821         ret = -1;
3822         goto the_end;
3823     }
3824     for(;;) {
3825         len = qemu_get_byte(f);
3826         if (feof(f))
3827             break;
3828         qemu_get_buffer(f, idstr, len);
3829         idstr[len] = '\0';
3830         instance_id = qemu_get_be32(f);
3831         version_id = qemu_get_be32(f);
3832         record_len = qemu_get_be32(f);
3833 #if 0
3834         printf("idstr=%s instance=0x%x version=%d len=%d\n",
3835                idstr, instance_id, version_id, record_len);
3836 #endif
3837         cur_pos = ftell(f);
3838         se = find_se(idstr, instance_id);
3839         if (!se) {
3840             fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
3841                     instance_id, idstr);
3842         } else {
3843             ret = se->load_state(f, se->opaque, version_id);
3844             if (ret < 0) {
3845                 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
3846                         instance_id, idstr);
3847             }
3848         }
3849         /* always seek to exact end of record */
3850         qemu_fseek(f, cur_pos + record_len, SEEK_SET);
3851     }
3852     fclose(f);
3853     ret = 0;
3854  the_end:
3855     if (saved_vm_running)
3856         vm_start();
3857     return ret;
3858 }
3859
3860 /***********************************************************/
3861 /* cpu save/restore */
3862
3863 #if defined(TARGET_I386)
3864
3865 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
3866 {
3867     qemu_put_be32(f, dt->selector);
3868     qemu_put_betl(f, dt->base);
3869     qemu_put_be32(f, dt->limit);
3870     qemu_put_be32(f, dt->flags);
3871 }
3872
3873 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
3874 {
3875     dt->selector = qemu_get_be32(f);
3876     dt->base = qemu_get_betl(f);
3877     dt->limit = qemu_get_be32(f);
3878     dt->flags = qemu_get_be32(f);
3879 }
3880
3881 void cpu_save(QEMUFile *f, void *opaque)
3882 {
3883     CPUState *env = opaque;
3884     uint16_t fptag, fpus, fpuc, fpregs_format;
3885     uint32_t hflags;
3886     int i;
3887
3888     for(i = 0; i < CPU_NB_REGS; i++)
3889         qemu_put_betls(f, &env->regs[i]);
3890     qemu_put_betls(f, &env->eip);
3891     qemu_put_betls(f, &env->eflags);
3892     hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
3893     qemu_put_be32s(f, &hflags);
3894
3895     /* FPU */
3896     fpuc = env->fpuc;
3897     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3898     fptag = 0;
3899     for(i = 0; i < 8; i++) {
3900         fptag |= ((!env->fptags[i]) << i);
3901     }
3902
3903     qemu_put_be16s(f, &fpuc);
3904     qemu_put_be16s(f, &fpus);
3905     qemu_put_be16s(f, &fptag);
3906
3907 #ifdef USE_X86LDOUBLE
3908     fpregs_format = 0;
3909 #else
3910     fpregs_format = 1;
3911 #endif
3912     qemu_put_be16s(f, &fpregs_format);
3913
3914     for(i = 0; i < 8; i++) {
3915 #ifdef USE_X86LDOUBLE
3916         {
3917             uint64_t mant;
3918             uint16_t exp;
3919             /* we save the real CPU data (in case of MMX usage only 'mant'
3920                contains the MMX register */
3921             cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
3922             qemu_put_be64(f, mant);
3923             qemu_put_be16(f, exp);
3924         }
3925 #else
3926         /* if we use doubles for float emulation, we save the doubles to
3927            avoid losing information in case of MMX usage. It can give
3928            problems if the image is restored on a CPU where long
3929            doubles are used instead. */
3930         qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
3931 #endif
3932     }
3933
3934     for(i = 0; i < 6; i++)
3935         cpu_put_seg(f, &env->segs[i]);
3936     cpu_put_seg(f, &env->ldt);
3937     cpu_put_seg(f, &env->tr);
3938     cpu_put_seg(f, &env->gdt);
3939     cpu_put_seg(f, &env->idt);
3940
3941     qemu_put_be32s(f, &env->sysenter_cs);
3942     qemu_put_be32s(f, &env->sysenter_esp);
3943     qemu_put_be32s(f, &env->sysenter_eip);
3944
3945     qemu_put_betls(f, &env->cr[0]);
3946     qemu_put_betls(f, &env->cr[2]);
3947     qemu_put_betls(f, &env->cr[3]);
3948     qemu_put_betls(f, &env->cr[4]);
3949
3950     for(i = 0; i < 8; i++)
3951         qemu_put_betls(f, &env->dr[i]);
3952
3953     /* MMU */
3954     qemu_put_be32s(f, &env->a20_mask);
3955
3956     /* XMM */
3957     qemu_put_be32s(f, &env->mxcsr);
3958     for(i = 0; i < CPU_NB_REGS; i++) {
3959         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
3960         qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
3961     }
3962
3963 #ifdef TARGET_X86_64
3964     qemu_put_be64s(f, &env->efer);
3965     qemu_put_be64s(f, &env->star);
3966     qemu_put_be64s(f, &env->lstar);
3967     qemu_put_be64s(f, &env->cstar);
3968     qemu_put_be64s(f, &env->fmask);
3969     qemu_put_be64s(f, &env->kernelgsbase);
3970 #endif
3971 }
3972
3973 #ifdef USE_X86LDOUBLE
3974 /* XXX: add that in a FPU generic layer */
3975 union x86_longdouble {
3976     uint64_t mant;
3977     uint16_t exp;
3978 };
3979
3980 #define MANTD1(fp)      (fp & ((1LL << 52) - 1))
3981 #define EXPBIAS1 1023
3982 #define EXPD1(fp)       ((fp >> 52) & 0x7FF)
3983 #define SIGND1(fp)      ((fp >> 32) & 0x80000000)
3984
3985 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
3986 {
3987     int e;
3988     /* mantissa */
3989     p->mant = (MANTD1(temp) << 11) | (1LL << 63);
3990     /* exponent + sign */
3991     e = EXPD1(temp) - EXPBIAS1 + 16383;
3992     e |= SIGND1(temp) >> 16;
3993     p->exp = e;
3994 }
3995 #endif
3996
3997 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3998 {
3999     CPUState *env = opaque;
4000     int i, guess_mmx;
4001     uint32_t hflags;
4002     uint16_t fpus, fpuc, fptag, fpregs_format;
4003
4004     if (version_id != 3)
4005         return -EINVAL;
4006     for(i = 0; i < CPU_NB_REGS; i++)
4007         qemu_get_betls(f, &env->regs[i]);
4008     qemu_get_betls(f, &env->eip);
4009     qemu_get_betls(f, &env->eflags);
4010     qemu_get_be32s(f, &hflags);
4011
4012     qemu_get_be16s(f, &fpuc);
4013     qemu_get_be16s(f, &fpus);
4014     qemu_get_be16s(f, &fptag);
4015     qemu_get_be16s(f, &fpregs_format);
4016
4017     /* NOTE: we cannot always restore the FPU state if the image come
4018        from a host with a different 'USE_X86LDOUBLE' define. We guess
4019        if we are in an MMX state to restore correctly in that case. */
4020     guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
4021     for(i = 0; i < 8; i++) {
4022         uint64_t mant;
4023         uint16_t exp;
4024
4025         switch(fpregs_format) {
4026         case 0:
4027             mant = qemu_get_be64(f);
4028             exp = qemu_get_be16(f);
4029 #ifdef USE_X86LDOUBLE
4030             env->fpregs[i].d = cpu_set_fp80(mant, exp);
4031 #else
4032             /* difficult case */
4033             if (guess_mmx)
4034                 env->fpregs[i].mmx.MMX_Q(0) = mant;
4035             else
4036                 env->fpregs[i].d = cpu_set_fp80(mant, exp);
4037 #endif
4038             break;
4039         case 1:
4040             mant = qemu_get_be64(f);
4041 #ifdef USE_X86LDOUBLE
4042             {
4043                 union x86_longdouble *p;
4044                 /* difficult case */
4045                 p = (void *)&env->fpregs[i];
4046                 if (guess_mmx) {
4047                     p->mant = mant;
4048                     p->exp = 0xffff;
4049                 } else {
4050                     fp64_to_fp80(p, mant);
4051                 }
4052             }
4053 #else
4054             env->fpregs[i].mmx.MMX_Q(0) = mant;
4055 #endif
4056             break;
4057         default:
4058             return -EINVAL;
4059         }
4060     }
4061
4062     env->fpuc = fpuc;
4063     /* XXX: restore FPU round state */
4064     env->fpstt = (fpus >> 11) & 7;
4065     env->fpus = fpus & ~0x3800;
4066     fptag ^= 0xff;
4067     for(i = 0; i < 8; i++) {
4068         env->fptags[i] = (fptag >> i) & 1;
4069     }
4070
4071     for(i = 0; i < 6; i++)
4072         cpu_get_seg(f, &env->segs[i]);
4073     cpu_get_seg(f, &env->ldt);
4074     cpu_get_seg(f, &env->tr);
4075     cpu_get_seg(f, &env->gdt);
4076     cpu_get_seg(f, &env->idt);
4077
4078     qemu_get_be32s(f, &env->sysenter_cs);
4079     qemu_get_be32s(f, &env->sysenter_esp);
4080     qemu_get_be32s(f, &env->sysenter_eip);
4081
4082     qemu_get_betls(f, &env->cr[0]);
4083     qemu_get_betls(f, &env->cr[2]);
4084     qemu_get_betls(f, &env->cr[3]);
4085     qemu_get_betls(f, &env->cr[4]);
4086
4087     for(i = 0; i < 8; i++)
4088         qemu_get_betls(f, &env->dr[i]);
4089
4090     /* MMU */
4091     qemu_get_be32s(f, &env->a20_mask);
4092
4093     qemu_get_be32s(f, &env->mxcsr);
4094     for(i = 0; i < CPU_NB_REGS; i++) {
4095         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
4096         qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
4097     }
4098
4099 #ifdef TARGET_X86_64
4100     qemu_get_be64s(f, &env->efer);
4101     qemu_get_be64s(f, &env->star);
4102     qemu_get_be64s(f, &env->lstar);
4103     qemu_get_be64s(f, &env->cstar);
4104     qemu_get_be64s(f, &env->fmask);
4105     qemu_get_be64s(f, &env->kernelgsbase);
4106 #endif
4107
4108     /* XXX: compute hflags from scratch, except for CPL and IIF */
4109     env->hflags = hflags;
4110     tlb_flush(env, 1);
4111     return 0;
4112 }
4113
4114 #elif defined(TARGET_PPC)
4115 void cpu_save(QEMUFile *f, void *opaque)
4116 {
4117 }
4118
4119 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4120 {
4121     return 0;
4122 }
4123
4124 #elif defined(TARGET_MIPS)
4125 void cpu_save(QEMUFile *f, void *opaque)
4126 {
4127 }
4128
4129 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4130 {
4131     return 0;
4132 }
4133
4134 #elif defined(TARGET_SPARC)
4135 void cpu_save(QEMUFile *f, void *opaque)
4136 {
4137     CPUState *env = opaque;
4138     int i;
4139     uint32_t tmp;
4140
4141     for(i = 0; i < 8; i++)
4142         qemu_put_betls(f, &env->gregs[i]);
4143     for(i = 0; i < NWINDOWS * 16; i++)
4144         qemu_put_betls(f, &env->regbase[i]);
4145
4146     /* FPU */
4147     for(i = 0; i < TARGET_FPREGS; i++) {
4148         union {
4149             TARGET_FPREG_T f;
4150             target_ulong i;
4151         } u;
4152         u.f = env->fpr[i];
4153         qemu_put_betl(f, u.i);
4154     }
4155
4156     qemu_put_betls(f, &env->pc);
4157     qemu_put_betls(f, &env->npc);
4158     qemu_put_betls(f, &env->y);
4159     tmp = GET_PSR(env);
4160     qemu_put_be32(f, tmp);
4161     qemu_put_betls(f, &env->fsr);
4162     qemu_put_betls(f, &env->tbr);
4163 #ifndef TARGET_SPARC64
4164     qemu_put_be32s(f, &env->wim);
4165     /* MMU */
4166     for(i = 0; i < 16; i++)
4167         qemu_put_be32s(f, &env->mmuregs[i]);
4168 #endif
4169 }
4170
4171 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4172 {
4173     CPUState *env = opaque;
4174     int i;
4175     uint32_t tmp;
4176
4177     for(i = 0; i < 8; i++)
4178         qemu_get_betls(f, &env->gregs[i]);
4179     for(i = 0; i < NWINDOWS * 16; i++)
4180         qemu_get_betls(f, &env->regbase[i]);
4181
4182     /* FPU */
4183     for(i = 0; i < TARGET_FPREGS; i++) {
4184         union {
4185             TARGET_FPREG_T f;
4186             target_ulong i;
4187         } u;
4188         u.i = qemu_get_betl(f);
4189         env->fpr[i] = u.f;
4190     }
4191
4192     qemu_get_betls(f, &env->pc);
4193     qemu_get_betls(f, &env->npc);
4194     qemu_get_betls(f, &env->y);
4195     tmp = qemu_get_be32(f);
4196     env->cwp = 0; /* needed to ensure that the wrapping registers are
4197                      correctly updated */
4198     PUT_PSR(env, tmp);
4199     qemu_get_betls(f, &env->fsr);
4200     qemu_get_betls(f, &env->tbr);
4201 #ifndef TARGET_SPARC64
4202     qemu_get_be32s(f, &env->wim);
4203     /* MMU */
4204     for(i = 0; i < 16; i++)
4205         qemu_get_be32s(f, &env->mmuregs[i]);
4206 #endif
4207     tlb_flush(env, 1);
4208     return 0;
4209 }
4210
4211 #elif defined(TARGET_ARM)
4212
4213 /* ??? Need to implement these.  */
4214 void cpu_save(QEMUFile *f, void *opaque)
4215 {
4216 }
4217
4218 int cpu_load(QEMUFile *f, void *opaque, int version_id)
4219 {
4220     return 0;
4221 }
4222
4223 #else
4224
4225 #warning No CPU save/restore functions
4226
4227 #endif
4228
4229 /***********************************************************/
4230 /* ram save/restore */
4231
4232 /* we just avoid storing empty pages */
4233 static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
4234 {
4235     int i, v;
4236
4237     v = buf[0];
4238     for(i = 1; i < len; i++) {
4239         if (buf[i] != v)
4240             goto normal_save;
4241     }
4242     qemu_put_byte(f, 1);
4243     qemu_put_byte(f, v);
4244     return;
4245  normal_save:
4246     qemu_put_byte(f, 0);
4247     qemu_put_buffer(f, buf, len);
4248 }
4249
4250 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
4251 {
4252     int v;
4253
4254     v = qemu_get_byte(f);
4255     switch(v) {
4256     case 0:
4257         if (qemu_get_buffer(f, buf, len) != len)
4258             return -EIO;
4259         break;
4260     case 1:
4261         v = qemu_get_byte(f);
4262         memset(buf, v, len);
4263         break;
4264     default:
4265         return -EINVAL;
4266     }
4267     return 0;
4268 }
4269
4270 static void ram_save(QEMUFile *f, void *opaque)
4271 {
4272     int i;
4273     qemu_put_be32(f, phys_ram_size);
4274     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
4275         ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
4276     }
4277 }
4278
4279 static int ram_load(QEMUFile *f, void *opaque, int version_id)
4280 {
4281     int i, ret;
4282
4283     if (version_id != 1)
4284         return -EINVAL;
4285     if (qemu_get_be32(f) != phys_ram_size)
4286         return -EINVAL;
4287     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
4288         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
4289         if (ret)
4290             return ret;
4291     }
4292     return 0;
4293 }
4294
4295 /***********************************************************/
4296 /* machine registration */
4297
4298 QEMUMachine *first_machine = NULL;
4299
4300 int qemu_register_machine(QEMUMachine *m)
4301 {
4302     QEMUMachine **pm;
4303     pm = &first_machine;
4304     while (*pm != NULL)
4305         pm = &(*pm)->next;
4306     m->next = NULL;
4307     *pm = m;
4308     return 0;
4309 }
4310
4311 QEMUMachine *find_machine(const char *name)
4312 {
4313     QEMUMachine *m;
4314
4315     for(m = first_machine; m != NULL; m = m->next) {
4316         if (!strcmp(m->name, name))
4317             return m;
4318     }
4319     return NULL;
4320 }
4321
4322 /***********************************************************/
4323 /* main execution loop */
4324
4325 void gui_update(void *opaque)
4326 {
4327     display_state.dpy_refresh(&display_state);
4328     qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
4329 }
4330
4331 struct vm_change_state_entry {
4332     VMChangeStateHandler *cb;
4333     void *opaque;
4334     LIST_ENTRY (vm_change_state_entry) entries;
4335 };
4336
4337 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
4338
4339 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
4340                                                      void *opaque)
4341 {
4342     VMChangeStateEntry *e;
4343
4344     e = qemu_mallocz(sizeof (*e));
4345     if (!e)
4346         return NULL;
4347
4348     e->cb = cb;
4349     e->opaque = opaque;
4350     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
4351     return e;
4352 }
4353
4354 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
4355 {
4356     LIST_REMOVE (e, entries);
4357     qemu_free (e);
4358 }
4359
4360 static void vm_state_notify(int running)
4361 {
4362     VMChangeStateEntry *e;
4363
4364     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
4365         e->cb(e->opaque, running);
4366     }
4367 }
4368
4369 /* XXX: support several handlers */
4370 static VMStopHandler *vm_stop_cb;
4371 static void *vm_stop_opaque;
4372
4373 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
4374 {
4375     vm_stop_cb = cb;
4376     vm_stop_opaque = opaque;
4377     return 0;
4378 }
4379
4380 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
4381 {
4382     vm_stop_cb = NULL;
4383 }
4384
4385 void vm_start(void)
4386 {
4387     if (!vm_running) {
4388         cpu_enable_ticks();
4389         vm_running = 1;
4390         vm_state_notify(1);
4391     }
4392 }
4393
4394 void vm_stop(int reason)
4395 {
4396     if (vm_running) {
4397         cpu_disable_ticks();
4398         vm_running = 0;
4399         if (reason != 0) {
4400             if (vm_stop_cb) {
4401                 vm_stop_cb(vm_stop_opaque, reason);
4402             }
4403         }
4404         vm_state_notify(0);
4405     }
4406 }
4407
4408 /* reset/shutdown handler */
4409
4410 typedef struct QEMUResetEntry {
4411     QEMUResetHandler *func;
4412     void *opaque;
4413     struct QEMUResetEntry *next;
4414 } QEMUResetEntry;
4415
4416 static QEMUResetEntry *first_reset_entry;
4417 static int reset_requested;
4418 static int shutdown_requested;
4419 static int powerdown_requested;
4420
4421 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
4422 {
4423     QEMUResetEntry **pre, *re;
4424
4425     pre = &first_reset_entry;
4426     while (*pre != NULL)
4427         pre = &(*pre)->next;
4428     re = qemu_mallocz(sizeof(QEMUResetEntry));
4429     re->func = func;
4430     re->opaque = opaque;
4431     re->next = NULL;
4432     *pre = re;
4433 }
4434
4435 void qemu_system_reset(void)
4436 {
4437     QEMUResetEntry *re;
4438
4439     /* reset all devices */
4440     for(re = first_reset_entry; re != NULL; re = re->next) {
4441         re->func(re->opaque);
4442     }
4443 }
4444
4445 void qemu_system_reset_request(void)
4446 {
4447     reset_requested = 1;
4448     if (cpu_single_env)
4449         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
4450 }
4451
4452 void qemu_system_shutdown_request(void)
4453 {
4454     shutdown_requested = 1;
4455     if (cpu_single_env)
4456         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
4457 }
4458
4459 void qemu_system_powerdown_request(void)
4460 {
4461     powerdown_requested = 1;
4462     if (cpu_single_env)
4463         cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
4464 }
4465
4466 void main_loop_wait(int timeout)
4467 {
4468     IOHandlerRecord *ioh, *ioh_next;
4469     fd_set rfds, wfds, xfds;
4470     int ret, nfds;
4471     struct timeval tv;
4472     PollingEntry *pe;
4473
4474
4475     /* XXX: need to suppress polling by better using win32 events */
4476     ret = 0;
4477     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4478         ret |= pe->func(pe->opaque);
4479     }
4480 #ifdef _WIN32
4481     if (ret == 0 && timeout > 0) {
4482             int err;
4483             HANDLE hEvents[1];
4484
4485             hEvents[0] = host_alarm;
4486             ret = WaitForMultipleObjects(1, hEvents, FALSE, timeout);
4487             switch(ret) {
4488             case WAIT_OBJECT_0 + 0:
4489                 break;
4490             case WAIT_TIMEOUT:
4491                 break;
4492             default:
4493                 err = GetLastError();
4494                 fprintf(stderr, "Wait error %d %d\n", ret, err);
4495                 break;
4496             }
4497     }
4498 #endif
4499     /* poll any events */
4500     /* XXX: separate device handlers from system ones */
4501     nfds = -1;
4502     FD_ZERO(&rfds);
4503     FD_ZERO(&wfds);
4504     FD_ZERO(&xfds);
4505     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4506         if (ioh->fd_read &&
4507             (!ioh->fd_read_poll ||
4508              ioh->fd_read_poll(ioh->opaque) != 0)) {
4509             FD_SET(ioh->fd, &rfds);
4510             if (ioh->fd > nfds)
4511                 nfds = ioh->fd;
4512         }
4513         if (ioh->fd_write) {
4514             FD_SET(ioh->fd, &wfds);
4515             if (ioh->fd > nfds)
4516                 nfds = ioh->fd;
4517         }
4518     }
4519
4520     tv.tv_sec = 0;
4521 #ifdef _WIN32
4522     tv.tv_usec = 0;
4523 #else
4524     tv.tv_usec = timeout * 1000;
4525 #endif
4526 #if defined(CONFIG_SLIRP)
4527     if (slirp_inited) {
4528         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4529     }
4530 #endif
4531     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4532     if (ret > 0) {
4533         /* XXX: better handling of removal */
4534         for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
4535             ioh_next = ioh->next;
4536             if (FD_ISSET(ioh->fd, &rfds)) {
4537                 ioh->fd_read(ioh->opaque);
4538             }
4539             if (FD_ISSET(ioh->fd, &wfds)) {
4540                 ioh->fd_write(ioh->opaque);
4541             }
4542         }
4543     }
4544 #if defined(CONFIG_SLIRP)
4545     if (slirp_inited) {
4546         if (ret < 0) {
4547             FD_ZERO(&rfds);
4548             FD_ZERO(&wfds);
4549             FD_ZERO(&xfds);
4550         }
4551         slirp_select_poll(&rfds, &wfds, &xfds);
4552     }
4553 #endif
4554 #ifdef _WIN32
4555     tap_win32_poll();
4556 #endif
4557
4558     if (vm_running) {
4559         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4560                         qemu_get_clock(vm_clock));
4561         /* run dma transfers, if any */
4562         DMA_run();
4563     }
4564
4565     /* real time timers */
4566     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4567                     qemu_get_clock(rt_clock));
4568 }
4569
4570 static CPUState *cur_cpu;
4571
4572 int main_loop(void)
4573 {
4574     int ret, timeout;
4575 #ifdef CONFIG_PROFILER
4576     int64_t ti;
4577 #endif
4578     CPUState *env;
4579
4580     cur_cpu = first_cpu;
4581     for(;;) {
4582         if (vm_running) {
4583
4584             env = cur_cpu;
4585             for(;;) {
4586                 /* get next cpu */
4587                 env = env->next_cpu;
4588                 if (!env)
4589                     env = first_cpu;
4590 #ifdef CONFIG_PROFILER
4591                 ti = profile_getclock();
4592 #endif
4593                 ret = cpu_exec(env);
4594 #ifdef CONFIG_PROFILER
4595                 qemu_time += profile_getclock() - ti;
4596 #endif
4597                 if (ret != EXCP_HALTED)
4598                     break;
4599                 /* all CPUs are halted ? */
4600                 if (env == cur_cpu) {
4601                     ret = EXCP_HLT;
4602                     break;
4603                 }
4604             }
4605             cur_cpu = env;
4606
4607             if (shutdown_requested) {
4608                 ret = EXCP_INTERRUPT;
4609                 break;
4610             }
4611             if (reset_requested) {
4612                 reset_requested = 0;
4613                 qemu_system_reset();
4614                 ret = EXCP_INTERRUPT;
4615             }
4616             if (powerdown_requested) {
4617                 powerdown_requested = 0;
4618                 qemu_system_powerdown();
4619                 ret = EXCP_INTERRUPT;
4620             }
4621             if (ret == EXCP_DEBUG) {
4622                 vm_stop(EXCP_DEBUG);
4623             }
4624             /* if hlt instruction, we wait until the next IRQ */
4625             /* XXX: use timeout computed from timers */
4626             if (ret == EXCP_HLT)
4627                 timeout = 10;
4628             else
4629                 timeout = 0;
4630         } else {
4631             timeout = 10;
4632         }
4633 #ifdef CONFIG_PROFILER
4634         ti = profile_getclock();
4635 #endif
4636         main_loop_wait(timeout);
4637 #ifdef CONFIG_PROFILER
4638         dev_time += profile_getclock() - ti;
4639 #endif
4640     }
4641     cpu_disable_ticks();
4642     return ret;
4643 }
4644
4645 void help(void)
4646 {
4647     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n"
4648            "usage: %s [options] [disk_image]\n"
4649            "\n"
4650            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4651            "\n"
4652            "Standard options:\n"
4653            "-M machine      select emulated machine (-M ? for list)\n"
4654            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
4655            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
4656            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
4657            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
4658            "-boot [a|c|d]   boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
4659            "-snapshot       write to temporary files instead of disk image files\n"
4660 #ifdef TARGET_I386
4661            "-no-fd-bootchk  disable boot signature checking for floppy disks\n"
4662 #endif
4663            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
4664            "-smp n          set the number of CPUs to 'n' [default=1]\n"
4665            "-nographic      disable graphical output and redirect serial I/Os to console\n"
4666 #ifndef _WIN32
4667            "-k language     use keyboard layout (for example \"fr\" for French)\n"
4668 #endif
4669 #ifdef HAS_AUDIO
4670            "-audio-help     print list of audio drivers and their options\n"
4671            "-soundhw c1,... enable audio support\n"
4672            "                and only specified sound cards (comma separated list)\n"
4673            "                use -soundhw ? to get the list of supported cards\n"
4674            "                use -soundhw all to enable all of them\n"
4675 #endif
4676            "-localtime      set the real time clock to local time [default=utc]\n"
4677            "-full-screen    start in full screen\n"
4678 #ifdef TARGET_I386
4679            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
4680 #endif
4681            "-usb            enable the USB driver (will be the default soon)\n"
4682            "-usbdevice name add the host or guest USB device 'name'\n"
4683 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4684            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
4685 #endif
4686            "\n"
4687            "Network options:\n"
4688            "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
4689            "                create a new Network Interface Card and connect it to VLAN 'n'\n"
4690 #ifdef CONFIG_SLIRP
4691            "-net user[,vlan=n][,hostname=host]\n"
4692            "                connect the user mode network stack to VLAN 'n' and send\n"
4693            "                hostname 'host' to DHCP clients\n"
4694 #endif
4695 #ifdef _WIN32
4696            "-net tap[,vlan=n],ifname=name\n"
4697            "                connect the host TAP network interface to VLAN 'n'\n"
4698 #else
4699            "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
4700            "                connect the host TAP network interface to VLAN 'n' and use\n"
4701            "                the network script 'file' (default=%s);\n"
4702            "                use 'fd=h' to connect to an already opened TAP interface\n"
4703 #endif
4704            "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
4705            "                connect the vlan 'n' to another VLAN using a socket connection\n"
4706            "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
4707            "                connect the vlan 'n' to multicast maddr and port\n"
4708            "-net none       use it alone to have zero network devices; if no -net option\n"
4709            "                is provided, the default is '-net nic -net user'\n"
4710            "\n"
4711 #ifdef CONFIG_SLIRP
4712            "-tftp prefix    allow tftp access to files starting with prefix [-net user]\n"
4713 #ifndef _WIN32
4714            "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
4715 #endif
4716            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
4717            "                redirect TCP or UDP connections from host to guest [-net user]\n"
4718 #endif
4719            "\n"
4720            "Linux boot specific:\n"
4721            "-kernel bzImage use 'bzImage' as kernel image\n"
4722            "-append cmdline use 'cmdline' as kernel command line\n"
4723            "-initrd file    use 'file' as initial ram disk\n"
4724            "\n"
4725            "Debug/Expert options:\n"
4726            "-monitor dev    redirect the monitor to char device 'dev'\n"
4727            "-serial dev     redirect the serial port to char device 'dev'\n"
4728            "-parallel dev   redirect the parallel port to char device 'dev'\n"
4729            "-pidfile file   Write PID to 'file'\n"
4730            "-S              freeze CPU at startup (use 'c' to start execution)\n"
4731            "-s              wait gdb connection to port %d\n"
4732            "-p port         change gdb connection port\n"
4733            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
4734            "-hdachs c,h,s[,t]  force hard disk 0 physical geometry and the optional BIOS\n"
4735            "                translation (t=none or lba) (usually qemu can guess them)\n"
4736            "-L path         set the directory for the BIOS and VGA BIOS\n"
4737 #ifdef USE_KQEMU
4738            "-kernel-kqemu   enable KQEMU full virtualization (default is user mode only)\n"
4739            "-no-kqemu       disable KQEMU kernel module usage\n"
4740 #endif
4741 #ifdef USE_CODE_COPY
4742            "-no-code-copy   disable code copy acceleration\n"
4743 #endif
4744 #ifdef TARGET_I386
4745            "-std-vga        simulate a standard VGA card with VESA Bochs Extensions\n"
4746            "                (default is CL-GD5446 PCI VGA)\n"
4747            "-no-acpi        disable ACPI\n"
4748 #endif
4749            "-loadvm file    start right away with a saved state (loadvm in monitor)\n"
4750            "-vnc display    start a VNC server on display\n"
4751            "\n"
4752            "During emulation, the following keys are useful:\n"
4753            "ctrl-alt-f      toggle full screen\n"
4754            "ctrl-alt-n      switch to virtual console 'n'\n"
4755            "ctrl-alt        toggle mouse and keyboard grab\n"
4756            "\n"
4757            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4758            ,
4759 #ifdef CONFIG_SOFTMMU
4760            "qemu",
4761 #else
4762            "qemu-fast",
4763 #endif
4764            DEFAULT_RAM_SIZE,
4765 #ifndef _WIN32
4766            DEFAULT_NETWORK_SCRIPT,
4767 #endif
4768            DEFAULT_GDBSTUB_PORT,
4769            "/tmp/qemu.log");
4770 #ifndef CONFIG_SOFTMMU
4771     printf("\n"
4772            "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
4773            "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
4774            "PC emulation.\n");
4775 #endif
4776     exit(1);
4777 }
4778
4779 #define HAS_ARG 0x0001
4780
4781 enum {
4782     QEMU_OPTION_h,
4783
4784     QEMU_OPTION_M,
4785     QEMU_OPTION_fda,
4786     QEMU_OPTION_fdb,
4787     QEMU_OPTION_hda,
4788     QEMU_OPTION_hdb,
4789     QEMU_OPTION_hdc,
4790     QEMU_OPTION_hdd,
4791     QEMU_OPTION_cdrom,
4792     QEMU_OPTION_boot,
4793     QEMU_OPTION_snapshot,
4794 #ifdef TARGET_I386
4795     QEMU_OPTION_no_fd_bootchk,
4796 #endif
4797     QEMU_OPTION_m,
4798     QEMU_OPTION_nographic,
4799 #ifdef HAS_AUDIO
4800     QEMU_OPTION_audio_help,
4801     QEMU_OPTION_soundhw,
4802 #endif
4803
4804     QEMU_OPTION_net,
4805     QEMU_OPTION_tftp,
4806     QEMU_OPTION_smb,
4807     QEMU_OPTION_redir,
4808
4809     QEMU_OPTION_kernel,
4810     QEMU_OPTION_append,
4811     QEMU_OPTION_initrd,
4812
4813     QEMU_OPTION_S,
4814     QEMU_OPTION_s,
4815     QEMU_OPTION_p,
4816     QEMU_OPTION_d,
4817     QEMU_OPTION_hdachs,
4818     QEMU_OPTION_L,
4819     QEMU_OPTION_no_code_copy,
4820     QEMU_OPTION_k,
4821     QEMU_OPTION_localtime,
4822     QEMU_OPTION_cirrusvga,
4823     QEMU_OPTION_g,
4824     QEMU_OPTION_std_vga,
4825     QEMU_OPTION_monitor,
4826     QEMU_OPTION_serial,
4827     QEMU_OPTION_parallel,
4828     QEMU_OPTION_loadvm,
4829     QEMU_OPTION_full_screen,
4830     QEMU_OPTION_pidfile,
4831     QEMU_OPTION_no_kqemu,
4832     QEMU_OPTION_kernel_kqemu,
4833     QEMU_OPTION_win2k_hack,
4834     QEMU_OPTION_usb,
4835     QEMU_OPTION_usbdevice,
4836     QEMU_OPTION_smp,
4837     QEMU_OPTION_vnc,
4838     QEMU_OPTION_no_acpi,
4839 };
4840
4841 typedef struct QEMUOption {
4842     const char *name;
4843     int flags;
4844     int index;
4845 } QEMUOption;
4846
4847 const QEMUOption qemu_options[] = {
4848     { "h", 0, QEMU_OPTION_h },
4849
4850     { "M", HAS_ARG, QEMU_OPTION_M },
4851     { "fda", HAS_ARG, QEMU_OPTION_fda },
4852     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4853     { "hda", HAS_ARG, QEMU_OPTION_hda },
4854     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4855     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4856     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4857     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4858     { "boot", HAS_ARG, QEMU_OPTION_boot },
4859     { "snapshot", 0, QEMU_OPTION_snapshot },
4860 #ifdef TARGET_I386
4861     { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4862 #endif
4863     { "m", HAS_ARG, QEMU_OPTION_m },
4864     { "nographic", 0, QEMU_OPTION_nographic },
4865     { "k", HAS_ARG, QEMU_OPTION_k },
4866 #ifdef HAS_AUDIO
4867     { "audio-help", 0, QEMU_OPTION_audio_help },
4868     { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4869 #endif
4870
4871     { "net", HAS_ARG, QEMU_OPTION_net},
4872 #ifdef CONFIG_SLIRP
4873     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4874 #ifndef _WIN32
4875     { "smb", HAS_ARG, QEMU_OPTION_smb },
4876 #endif
4877     { "redir", HAS_ARG, QEMU_OPTION_redir },
4878 #endif
4879
4880     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4881     { "append", HAS_ARG, QEMU_OPTION_append },
4882     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4883
4884     { "S", 0, QEMU_OPTION_S },
4885     { "s", 0, QEMU_OPTION_s },
4886     { "p", HAS_ARG, QEMU_OPTION_p },
4887     { "d", HAS_ARG, QEMU_OPTION_d },
4888     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4889     { "L", HAS_ARG, QEMU_OPTION_L },
4890     { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
4891 #ifdef USE_KQEMU
4892     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4893     { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
4894 #endif
4895 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4896     { "g", 1, QEMU_OPTION_g },
4897 #endif
4898     { "localtime", 0, QEMU_OPTION_localtime },
4899     { "std-vga", 0, QEMU_OPTION_std_vga },
4900     { "monitor", 1, QEMU_OPTION_monitor },
4901     { "serial", 1, QEMU_OPTION_serial },
4902     { "parallel", 1, QEMU_OPTION_parallel },
4903     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4904     { "full-screen", 0, QEMU_OPTION_full_screen },
4905     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4906     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4907     { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4908     { "smp", HAS_ARG, QEMU_OPTION_smp },
4909     { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4910
4911     /* temporary options */
4912     { "usb", 0, QEMU_OPTION_usb },
4913     { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
4914     { "no-acpi", 0, QEMU_OPTION_no_acpi },
4915     { NULL },
4916 };
4917
4918 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
4919
4920 /* this stack is only used during signal handling */
4921 #define SIGNAL_STACK_SIZE 32768
4922
4923 static uint8_t *signal_stack;
4924
4925 #endif
4926
4927 /* password input */
4928
4929 static BlockDriverState *get_bdrv(int index)
4930 {
4931     BlockDriverState *bs;
4932
4933     if (index < 4) {
4934         bs = bs_table[index];
4935     } else if (index < 6) {
4936         bs = fd_table[index - 4];
4937     } else {
4938         bs = NULL;
4939     }
4940     return bs;
4941 }
4942
4943 static void read_passwords(void)
4944 {
4945     BlockDriverState *bs;
4946     int i, j;
4947     char password[256];
4948
4949     for(i = 0; i < 6; i++) {
4950         bs = get_bdrv(i);
4951         if (bs && bdrv_is_encrypted(bs)) {
4952             term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
4953             for(j = 0; j < 3; j++) {
4954                 monitor_readline("Password: ",
4955                                  1, password, sizeof(password));
4956                 if (bdrv_set_key(bs, password) == 0)
4957                     break;
4958                 term_printf("invalid password\n");
4959             }
4960         }
4961     }
4962 }
4963
4964 /* XXX: currently we cannot use simultaneously different CPUs */
4965 void register_machines(void)
4966 {
4967 #if defined(TARGET_I386)
4968     qemu_register_machine(&pc_machine);
4969     qemu_register_machine(&isapc_machine);
4970 #elif defined(TARGET_PPC)
4971     qemu_register_machine(&heathrow_machine);
4972     qemu_register_machine(&core99_machine);
4973     qemu_register_machine(&prep_machine);
4974 #elif defined(TARGET_MIPS)
4975     qemu_register_machine(&mips_machine);
4976 #elif defined(TARGET_SPARC)
4977 #ifdef TARGET_SPARC64
4978     qemu_register_machine(&sun4u_machine);
4979 #else
4980     qemu_register_machine(&sun4m_machine);
4981 #endif
4982 #elif defined(TARGET_ARM)
4983     qemu_register_machine(&integratorcp926_machine);
4984     qemu_register_machine(&integratorcp1026_machine);
4985     qemu_register_machine(&versatilepb_machine);
4986     qemu_register_machine(&versatileab_machine);
4987 #elif defined(TARGET_SH4)
4988     qemu_register_machine(&shix_machine);
4989 #else
4990 #error unsupported CPU
4991 #endif
4992 }
4993
4994 #ifdef HAS_AUDIO
4995 struct soundhw soundhw[] = {
4996 #ifdef TARGET_I386
4997     {
4998         "pcspk",
4999         "PC speaker",
5000         0,
5001         1,
5002         { .init_isa = pcspk_audio_init }
5003     },
5004 #endif
5005     {
5006         "sb16",
5007         "Creative Sound Blaster 16",
5008         0,
5009         1,
5010         { .init_isa = SB16_init }
5011     },
5012
5013 #ifdef CONFIG_ADLIB
5014     {
5015         "adlib",
5016 #ifdef HAS_YMF262
5017         "Yamaha YMF262 (OPL3)",
5018 #else
5019         "Yamaha YM3812 (OPL2)",
5020 #endif
5021         0,
5022         1,
5023         { .init_isa = Adlib_init }
5024     },
5025 #endif
5026
5027 #ifdef CONFIG_GUS
5028     {
5029         "gus",
5030         "Gravis Ultrasound GF1",
5031         0,
5032         1,
5033         { .init_isa = GUS_init }
5034     },
5035 #endif
5036
5037     {
5038         "es1370",
5039         "ENSONIQ AudioPCI ES1370",
5040         0,
5041         0,
5042         { .init_pci = es1370_init }
5043     },
5044
5045     { NULL, NULL, 0, 0, { NULL } }
5046 };
5047
5048 static void select_soundhw (const char *optarg)
5049 {
5050     struct soundhw *c;
5051
5052     if (*optarg == '?') {
5053     show_valid_cards:
5054
5055         printf ("Valid sound card names (comma separated):\n");
5056         for (c = soundhw; c->name; ++c) {
5057             printf ("%-11s %s\n", c->name, c->descr);
5058         }
5059         printf ("\n-soundhw all will enable all of the above\n");
5060         exit (*optarg != '?');
5061     }
5062     else {
5063         size_t l;
5064         const char *p;
5065         char *e;
5066         int bad_card = 0;
5067
5068         if (!strcmp (optarg, "all")) {
5069             for (c = soundhw; c->name; ++c) {
5070                 c->enabled = 1;
5071             }
5072             return;
5073         }
5074
5075         p = optarg;
5076         while (*p) {
5077             e = strchr (p, ',');
5078             l = !e ? strlen (p) : (size_t) (e - p);
5079
5080             for (c = soundhw; c->name; ++c) {
5081                 if (!strncmp (c->name, p, l)) {
5082                     c->enabled = 1;
5083                     break;
5084                 }
5085             }
5086
5087             if (!c->name) {
5088                 if (l > 80) {
5089                     fprintf (stderr,
5090                              "Unknown sound card name (too big to show)\n");
5091                 }
5092                 else {
5093                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
5094                              (int) l, p);
5095                 }
5096                 bad_card = 1;
5097             }
5098             p += l + (e != NULL);
5099         }
5100
5101         if (bad_card)
5102             goto show_valid_cards;
5103     }
5104 }
5105 #endif
5106
5107 #define MAX_NET_CLIENTS 32
5108
5109 int main(int argc, char **argv)
5110 {
5111 #ifdef CONFIG_GDBSTUB
5112     int use_gdbstub, gdbstub_port;
5113 #endif
5114     int i, cdrom_index;
5115     int snapshot, linux_boot;
5116     const char *initrd_filename;
5117     const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
5118     const char *kernel_filename, *kernel_cmdline;
5119     DisplayState *ds = &display_state;
5120     int cyls, heads, secs, translation;
5121     int start_emulation = 1;
5122     char net_clients[MAX_NET_CLIENTS][256];
5123     int nb_net_clients;
5124     int optind;
5125     const char *r, *optarg;
5126     CharDriverState *monitor_hd;
5127     char monitor_device[128];
5128     char serial_devices[MAX_SERIAL_PORTS][128];
5129     int serial_device_index;
5130     char parallel_devices[MAX_PARALLEL_PORTS][128];
5131     int parallel_device_index;
5132     const char *loadvm = NULL;
5133     QEMUMachine *machine;
5134     char usb_devices[MAX_USB_CMDLINE][128];
5135     int usb_devices_index;
5136
5137     LIST_INIT (&vm_change_state_head);
5138 #if !defined(CONFIG_SOFTMMU)
5139     /* we never want that malloc() uses mmap() */
5140     mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
5141 #endif
5142     register_machines();
5143     machine = first_machine;
5144     initrd_filename = NULL;
5145     for(i = 0; i < MAX_FD; i++)
5146         fd_filename[i] = NULL;
5147     for(i = 0; i < MAX_DISKS; i++)
5148         hd_filename[i] = NULL;
5149     ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5150     vga_ram_size = VGA_RAM_SIZE;
5151     bios_size = BIOS_SIZE;
5152 #ifdef CONFIG_GDBSTUB
5153     use_gdbstub = 0;
5154     gdbstub_port = DEFAULT_GDBSTUB_PORT;
5155 #endif
5156     snapshot = 0;
5157     nographic = 0;
5158     kernel_filename = NULL;
5159     kernel_cmdline = "";
5160 #ifdef TARGET_PPC
5161     cdrom_index = 1;
5162 #else
5163     cdrom_index = 2;
5164 #endif
5165     cyls = heads = secs = 0;
5166     translation = BIOS_ATA_TRANSLATION_AUTO;
5167     pstrcpy(monitor_device, sizeof(monitor_device), "vc");
5168
5169     pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
5170     for(i = 1; i < MAX_SERIAL_PORTS; i++)
5171         serial_devices[i][0] = '\0';
5172     serial_device_index = 0;
5173
5174     pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
5175     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
5176         parallel_devices[i][0] = '\0';
5177     parallel_device_index = 0;
5178
5179     usb_devices_index = 0;
5180
5181     nb_net_clients = 0;
5182
5183     nb_nics = 0;
5184     /* default mac address of the first network interface */
5185
5186     optind = 1;
5187     for(;;) {
5188         if (optind >= argc)
5189             break;
5190         r = argv[optind];
5191         if (r[0] != '-') {
5192             hd_filename[0] = argv[optind++];
5193         } else {
5194             const QEMUOption *popt;
5195
5196             optind++;
5197             popt = qemu_options;
5198             for(;;) {
5199                 if (!popt->name) {
5200                     fprintf(stderr, "%s: invalid option -- '%s'\n",
5201                             argv[0], r);
5202                     exit(1);
5203                 }
5204                 if (!strcmp(popt->name, r + 1))
5205                     break;
5206                 popt++;
5207             }
5208             if (popt->flags & HAS_ARG) {
5209                 if (optind >= argc) {
5210                     fprintf(stderr, "%s: option '%s' requires an argument\n",
5211                             argv[0], r);
5212                     exit(1);
5213                 }
5214                 optarg = argv[optind++];
5215             } else {
5216                 optarg = NULL;
5217             }
5218
5219             switch(popt->index) {
5220             case QEMU_OPTION_M:
5221                 machine = find_machine(optarg);
5222                 if (!machine) {
5223                     QEMUMachine *m;
5224                     printf("Supported machines are:\n");
5225                     for(m = first_machine; m != NULL; m = m->next) {
5226                         printf("%-10s %s%s\n",
5227                                m->name, m->desc,
5228                                m == first_machine ? " (default)" : "");
5229                     }
5230                     exit(1);
5231                 }
5232                 break;
5233             case QEMU_OPTION_initrd:
5234                 initrd_filename = optarg;
5235                 break;
5236             case QEMU_OPTION_hda:
5237             case QEMU_OPTION_hdb:
5238             case QEMU_OPTION_hdc:
5239             case QEMU_OPTION_hdd:
5240                 {
5241                     int hd_index;
5242                     hd_index = popt->index - QEMU_OPTION_hda;
5243                     hd_filename[hd_index] = optarg;
5244                     if (hd_index == cdrom_index)
5245                         cdrom_index = -1;
5246                 }
5247                 break;
5248             case QEMU_OPTION_snapshot:
5249                 snapshot = 1;
5250                 break;
5251             case QEMU_OPTION_hdachs:
5252                 {
5253                     const char *p;
5254                     p = optarg;
5255                     cyls = strtol(p, (char **)&p, 0);
5256                     if (cyls < 1 || cyls > 16383)
5257                         goto chs_fail;
5258                     if (*p != ',')
5259                         goto chs_fail;
5260                     p++;
5261                     heads = strtol(p, (char **)&p, 0);
5262                     if (heads < 1 || heads > 16)
5263                         goto chs_fail;
5264                     if (*p != ',')
5265                         goto chs_fail;
5266                     p++;
5267                     secs = strtol(p, (char **)&p, 0);
5268                     if (secs < 1 || secs > 63)
5269                         goto chs_fail;
5270                     if (*p == ',') {
5271                         p++;
5272                         if (!strcmp(p, "none"))
5273                             translation = BIOS_ATA_TRANSLATION_NONE;
5274                         else if (!strcmp(p, "lba"))
5275                             translation = BIOS_ATA_TRANSLATION_LBA;
5276                         else if (!strcmp(p, "auto"))
5277                             translation = BIOS_ATA_TRANSLATION_AUTO;
5278                         else
5279                             goto chs_fail;
5280                     } else if (*p != '\0') {
5281                     chs_fail:
5282                         fprintf(stderr, "qemu: invalid physical CHS format\n");
5283                         exit(1);
5284                     }
5285                 }
5286                 break;
5287             case QEMU_OPTION_nographic:
5288                 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
5289                 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
5290                 nographic = 1;
5291                 break;
5292             case QEMU_OPTION_kernel:
5293                 kernel_filename = optarg;
5294                 break;
5295             case QEMU_OPTION_append:
5296                 kernel_cmdline = optarg;
5297                 break;
5298             case QEMU_OPTION_cdrom:
5299                 if (cdrom_index >= 0) {
5300                     hd_filename[cdrom_index] = optarg;
5301                 }
5302                 break;
5303             case QEMU_OPTION_boot:
5304                 boot_device = optarg[0];
5305                 if (boot_device != 'a' &&
5306 #ifdef TARGET_SPARC
5307                     // Network boot
5308                     boot_device != 'n' &&
5309 #endif
5310                     boot_device != 'c' && boot_device != 'd') {
5311                     fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
5312                     exit(1);
5313                 }
5314                 break;
5315             case QEMU_OPTION_fda:
5316                 fd_filename[0] = optarg;
5317                 break;
5318             case QEMU_OPTION_fdb:
5319                 fd_filename[1] = optarg;
5320                 break;
5321 #ifdef TARGET_I386
5322             case QEMU_OPTION_no_fd_bootchk:
5323                 fd_bootchk = 0;
5324                 break;
5325 #endif
5326             case QEMU_OPTION_no_code_copy:
5327                 code_copy_enabled = 0;
5328                 break;
5329             case QEMU_OPTION_net:
5330                 if (nb_net_clients >= MAX_NET_CLIENTS) {
5331                     fprintf(stderr, "qemu: too many network clients\n");
5332                     exit(1);
5333                 }
5334                 pstrcpy(net_clients[nb_net_clients],
5335                         sizeof(net_clients[0]),
5336                         optarg);
5337                 nb_net_clients++;
5338                 break;
5339 #ifdef CONFIG_SLIRP
5340             case QEMU_OPTION_tftp:
5341                 tftp_prefix = optarg;
5342                 break;
5343 #ifndef _WIN32
5344             case QEMU_OPTION_smb:
5345                 net_slirp_smb(optarg);
5346                 break;
5347 #endif
5348             case QEMU_OPTION_redir:
5349                 net_slirp_redir(optarg);
5350                 break;
5351 #endif
5352 #ifdef HAS_AUDIO
5353             case QEMU_OPTION_audio_help:
5354                 AUD_help ();
5355                 exit (0);
5356                 break;
5357             case QEMU_OPTION_soundhw:
5358                 select_soundhw (optarg);
5359                 break;
5360 #endif
5361             case QEMU_OPTION_h:
5362                 help();
5363                 break;
5364             case QEMU_OPTION_m:
5365                 ram_size = atoi(optarg) * 1024 * 1024;
5366                 if (ram_size <= 0)
5367                     help();
5368                 if (ram_size > PHYS_RAM_MAX_SIZE) {
5369                     fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
5370                             PHYS_RAM_MAX_SIZE / (1024 * 1024));
5371                     exit(1);
5372                 }
5373                 break;
5374             case QEMU_OPTION_d:
5375                 {
5376                     int mask;
5377                     CPULogItem *item;
5378
5379                     mask = cpu_str_to_log_mask(optarg);
5380                     if (!mask) {
5381                         printf("Log items (comma separated):\n");
5382                     for(item = cpu_log_items; item->mask != 0; item++) {
5383                         printf("%-10s %s\n", item->name, item->help);
5384                     }
5385                     exit(1);
5386                     }
5387                     cpu_set_log(mask);
5388                 }
5389                 break;
5390 #ifdef CONFIG_GDBSTUB
5391             case QEMU_OPTION_s:
5392                 use_gdbstub = 1;
5393                 break;
5394             case QEMU_OPTION_p:
5395                 gdbstub_port = atoi(optarg);
5396                 break;
5397 #endif
5398             case QEMU_OPTION_L:
5399                 bios_dir = optarg;
5400                 break;
5401             case QEMU_OPTION_S:
5402                 start_emulation = 0;
5403                 break;
5404             case QEMU_OPTION_k:
5405                 keyboard_layout = optarg;
5406                 break;
5407             case QEMU_OPTION_localtime:
5408                 rtc_utc = 0;
5409                 break;
5410             case QEMU_OPTION_cirrusvga:
5411                 cirrus_vga_enabled = 1;
5412                 break;
5413             case QEMU_OPTION_std_vga:
5414                 cirrus_vga_enabled = 0;
5415                 break;
5416             case QEMU_OPTION_g:
5417                 {
5418                     const char *p;
5419                     int w, h, depth;
5420                     p = optarg;
5421                     w = strtol(p, (char **)&p, 10);
5422                     if (w <= 0) {
5423                     graphic_error:
5424                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5425                         exit(1);
5426                     }
5427                     if (*p != 'x')
5428                         goto graphic_error;
5429                     p++;
5430                     h = strtol(p, (char **)&p, 10);
5431                     if (h <= 0)
5432                         goto graphic_error;
5433                     if (*p == 'x') {
5434                         p++;
5435                         depth = strtol(p, (char **)&p, 10);
5436                         if (depth != 8 && depth != 15 && depth != 16 &&
5437                             depth != 24 && depth != 32)
5438                             goto graphic_error;
5439                     } else if (*p == '\0') {
5440                         depth = graphic_depth;
5441                     } else {
5442                         goto graphic_error;
5443                     }
5444
5445                     graphic_width = w;
5446                     graphic_height = h;
5447                     graphic_depth = depth;
5448                 }
5449                 break;
5450             case QEMU_OPTION_monitor:
5451                 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
5452                 break;
5453             case QEMU_OPTION_serial:
5454                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5455                     fprintf(stderr, "qemu: too many serial ports\n");
5456                     exit(1);
5457                 }
5458                 pstrcpy(serial_devices[serial_device_index],
5459                         sizeof(serial_devices[0]), optarg);
5460                 serial_device_index++;
5461                 break;
5462             case QEMU_OPTION_parallel:
5463                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5464                     fprintf(stderr, "qemu: too many parallel ports\n");
5465                     exit(1);
5466                 }
5467                 pstrcpy(parallel_devices[parallel_device_index],
5468                         sizeof(parallel_devices[0]), optarg);
5469                 parallel_device_index++;
5470                 break;
5471             case QEMU_OPTION_loadvm:
5472                 loadvm = optarg;
5473                 break;
5474             case QEMU_OPTION_full_screen:
5475                 full_screen = 1;
5476                 break;
5477             case QEMU_OPTION_pidfile:
5478                 create_pidfile(optarg);
5479                 break;
5480 #ifdef TARGET_I386
5481             case QEMU_OPTION_win2k_hack:
5482                 win2k_install_hack = 1;
5483                 break;
5484 #endif
5485 #ifdef USE_KQEMU
5486             case QEMU_OPTION_no_kqemu:
5487                 kqemu_allowed = 0;
5488                 break;
5489             case QEMU_OPTION_kernel_kqemu:
5490                 kqemu_allowed = 2;
5491                 break;
5492 #endif
5493             case QEMU_OPTION_usb:
5494                 usb_enabled = 1;
5495                 break;
5496             case QEMU_OPTION_usbdevice:
5497                 usb_enabled = 1;
5498                 if (usb_devices_index >= MAX_USB_CMDLINE) {
5499                     fprintf(stderr, "Too many USB devices\n");
5500                     exit(1);
5501                 }
5502                 pstrcpy(usb_devices[usb_devices_index],
5503                         sizeof(usb_devices[usb_devices_index]),
5504                         optarg);
5505                 usb_devices_index++;
5506                 break;
5507             case QEMU_OPTION_smp:
5508                 smp_cpus = atoi(optarg);
5509                 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
5510                     fprintf(stderr, "Invalid number of CPUs\n");
5511                     exit(1);
5512                 }
5513                 break;
5514             case QEMU_OPTION_vnc:
5515                 vnc_display = atoi(optarg);
5516                 if (vnc_display < 0) {
5517                     fprintf(stderr, "Invalid VNC display\n");
5518                     exit(1);
5519                 }
5520                 break;
5521             case QEMU_OPTION_no_acpi:
5522                 acpi_enabled = 0;
5523                 break;
5524             }
5525         }
5526     }
5527
5528 #ifdef USE_KQEMU
5529     if (smp_cpus > 1)
5530         kqemu_allowed = 0;
5531 #endif
5532     linux_boot = (kernel_filename != NULL);
5533
5534     if (!linux_boot &&
5535         hd_filename[0] == '\0' &&
5536         (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
5537         fd_filename[0] == '\0')
5538         help();
5539
5540     /* boot to cd by default if no hard disk */
5541     if (hd_filename[0] == '\0' && boot_device == 'c') {
5542         if (fd_filename[0] != '\0')
5543             boot_device = 'a';
5544         else
5545             boot_device = 'd';
5546     }
5547
5548 #if !defined(CONFIG_SOFTMMU)
5549     /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
5550     {
5551         static uint8_t stdout_buf[4096];
5552         setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
5553     }
5554 #else
5555     setvbuf(stdout, NULL, _IOLBF, 0);
5556 #endif
5557
5558 #ifdef _WIN32
5559     socket_init();
5560 #endif
5561
5562     /* init network clients */
5563     if (nb_net_clients == 0) {
5564         /* if no clients, we use a default config */
5565         pstrcpy(net_clients[0], sizeof(net_clients[0]),
5566                 "nic");
5567         pstrcpy(net_clients[1], sizeof(net_clients[0]),
5568                 "user");
5569         nb_net_clients = 2;
5570     }
5571
5572     for(i = 0;i < nb_net_clients; i++) {
5573         if (net_client_init(net_clients[i]) < 0)
5574             exit(1);
5575     }
5576
5577     /* init the memory */
5578     phys_ram_size = ram_size + vga_ram_size + bios_size;
5579
5580 #ifdef CONFIG_SOFTMMU
5581     phys_ram_base = qemu_vmalloc(phys_ram_size);
5582     if (!phys_ram_base) {
5583         fprintf(stderr, "Could not allocate physical memory\n");
5584         exit(1);
5585     }
5586 #else
5587     /* as we must map the same page at several addresses, we must use
5588        a fd */
5589     {
5590         const char *tmpdir;
5591
5592         tmpdir = getenv("QEMU_TMPDIR");
5593         if (!tmpdir)
5594             tmpdir = "/tmp";
5595         snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
5596         if (mkstemp(phys_ram_file) < 0) {
5597             fprintf(stderr, "Could not create temporary memory file '%s'\n",
5598                     phys_ram_file);
5599             exit(1);
5600         }
5601         phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
5602         if (phys_ram_fd < 0) {
5603             fprintf(stderr, "Could not open temporary memory file '%s'\n",
5604                     phys_ram_file);
5605             exit(1);
5606         }
5607         ftruncate(phys_ram_fd, phys_ram_size);
5608         unlink(phys_ram_file);
5609         phys_ram_base = mmap(get_mmap_addr(phys_ram_size),
5610                              phys_ram_size,
5611                              PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED,
5612                              phys_ram_fd, 0);
5613         if (phys_ram_base == MAP_FAILED) {
5614             fprintf(stderr, "Could not map physical memory\n");
5615             exit(1);
5616         }
5617     }
5618 #endif
5619
5620     /* we always create the cdrom drive, even if no disk is there */
5621     bdrv_init();
5622     if (cdrom_index >= 0) {
5623         bs_table[cdrom_index] = bdrv_new("cdrom");
5624         bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
5625     }
5626
5627     /* open the virtual block devices */
5628     for(i = 0; i < MAX_DISKS; i++) {
5629         if (hd_filename[i]) {
5630             if (!bs_table[i]) {
5631                 char buf[64];
5632                 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
5633                 bs_table[i] = bdrv_new(buf);
5634             }
5635             if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
5636                 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
5637                         hd_filename[i]);
5638                 exit(1);
5639             }
5640             if (i == 0 && cyls != 0) {
5641                 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
5642                 bdrv_set_translation_hint(bs_table[i], translation);
5643             }
5644         }
5645     }
5646
5647     /* we always create at least one floppy disk */
5648     fd_table[0] = bdrv_new("fda");
5649     bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
5650
5651     for(i = 0; i < MAX_FD; i++) {
5652         if (fd_filename[i]) {
5653             if (!fd_table[i]) {
5654                 char buf[64];
5655                 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
5656                 fd_table[i] = bdrv_new(buf);
5657                 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
5658             }
5659             if (fd_filename[i] != '\0') {
5660                 if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
5661                     fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
5662                             fd_filename[i]);
5663                     exit(1);
5664                 }
5665             }
5666         }
5667     }
5668
5669     register_savevm("timer", 0, 1, timer_save, timer_load, NULL);
5670     register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
5671
5672     init_ioports();
5673     cpu_calibrate_ticks();
5674
5675     /* terminal init */
5676     if (nographic) {
5677         dumb_display_init(ds);
5678     } else if (vnc_display != -1) {
5679         vnc_display_init(ds, vnc_display);
5680     } else {
5681 #if defined(CONFIG_SDL)
5682         sdl_display_init(ds, full_screen);
5683 #elif defined(CONFIG_COCOA)
5684         cocoa_display_init(ds, full_screen);
5685 #else
5686         dumb_display_init(ds);
5687 #endif
5688     }
5689
5690     monitor_hd = qemu_chr_open(monitor_device);
5691     if (!monitor_hd) {
5692         fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5693         exit(1);
5694     }
5695     monitor_init(monitor_hd, !nographic);
5696
5697     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5698         if (serial_devices[i][0] != '\0') {
5699             serial_hds[i] = qemu_chr_open(serial_devices[i]);
5700             if (!serial_hds[i]) {
5701                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5702                         serial_devices[i]);
5703                 exit(1);
5704             }
5705             if (!strcmp(serial_devices[i], "vc"))
5706                 qemu_chr_printf(serial_hds[i], "serial%d console\n", i);
5707         }
5708     }
5709
5710     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5711         if (parallel_devices[i][0] != '\0') {
5712             parallel_hds[i] = qemu_chr_open(parallel_devices[i]);
5713             if (!parallel_hds[i]) {
5714                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5715                         parallel_devices[i]);
5716                 exit(1);
5717             }
5718             if (!strcmp(parallel_devices[i], "vc"))
5719                 qemu_chr_printf(parallel_hds[i], "parallel%d console\n", i);
5720         }
5721     }
5722
5723     /* setup cpu signal handlers for MMU / self modifying code handling */
5724 #if !defined(CONFIG_SOFTMMU)
5725
5726 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5727     {
5728         stack_t stk;
5729         signal_stack = memalign(16, SIGNAL_STACK_SIZE);
5730         stk.ss_sp = signal_stack;
5731         stk.ss_size = SIGNAL_STACK_SIZE;
5732         stk.ss_flags = 0;
5733
5734         if (sigaltstack(&stk, NULL) < 0) {
5735             perror("sigaltstack");
5736             exit(1);
5737         }
5738     }
5739 #endif
5740     {
5741         struct sigaction act;
5742
5743         sigfillset(&act.sa_mask);
5744         act.sa_flags = SA_SIGINFO;
5745 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5746         act.sa_flags |= SA_ONSTACK;
5747 #endif
5748         act.sa_sigaction = host_segv_handler;
5749         sigaction(SIGSEGV, &act, NULL);
5750         sigaction(SIGBUS, &act, NULL);
5751 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5752         sigaction(SIGFPE, &act, NULL);
5753 #endif
5754     }
5755 #endif
5756
5757 #ifndef _WIN32
5758     {
5759         struct sigaction act;
5760         sigfillset(&act.sa_mask);
5761         act.sa_flags = 0;
5762         act.sa_handler = SIG_IGN;
5763         sigaction(SIGPIPE, &act, NULL);
5764     }
5765 #endif
5766     init_timers();
5767
5768     machine->init(ram_size, vga_ram_size, boot_device,
5769                   ds, fd_filename, snapshot,
5770                   kernel_filename, kernel_cmdline, initrd_filename);
5771
5772     /* init USB devices */
5773     if (usb_enabled) {
5774         for(i = 0; i < usb_devices_index; i++) {
5775             if (usb_device_add(usb_devices[i]) < 0) {
5776                 fprintf(stderr, "Warning: could not add USB device %s\n",
5777                         usb_devices[i]);
5778             }
5779         }
5780     }
5781
5782     gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
5783     qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
5784
5785 #ifdef CONFIG_GDBSTUB
5786     if (use_gdbstub) {
5787         if (gdbserver_start(gdbstub_port) < 0) {
5788             fprintf(stderr, "Could not open gdbserver socket on port %d\n",
5789                     gdbstub_port);
5790             exit(1);
5791         } else {
5792             printf("Waiting gdb connection on port %d\n", gdbstub_port);
5793         }
5794     } else
5795 #endif
5796     if (loadvm)
5797         qemu_loadvm(loadvm);
5798
5799     {
5800         /* XXX: simplify init */
5801         read_passwords();
5802         if (start_emulation) {
5803             vm_start();
5804         }
5805     }
5806     main_loop();
5807     quit_timers();
5808     return 0;
5809 }